diff --git a/Tests/DapperTests.csproj b/Tests/DapperTests.csproj index 54f209fbbecf71262441fe618944f0d4932fb60d..f561a9dea03760f7574b135a019161e003ff1222 100644 --- a/Tests/DapperTests.csproj +++ b/Tests/DapperTests.csproj @@ -38,6 +38,21 @@ bltoolkit\BLToolkit.4.dll + + True + ..\packages\FSPowerPack.Community.2.0.0.0\Lib\Net40\FSharp.PowerPack.dll + + + True + ..\packages\FSPowerPack.Community.2.0.0.0\Lib\Net40\FSharp.PowerPack.Linq.dll + + + True + ..\packages\FSPowerPack.Community.2.0.0.0\Lib\Net40\FSharp.PowerPack.Metadata.dll + + + ..\packages\FSPowerPack.Community.2.0.0.0\Lib\Net40\FSharp.PowerPack.Parallel.Seq.dll + NHibernate\Iesi.Collections.dll @@ -79,6 +94,18 @@ Simple.Data\Simple.Data.SqlServer.dll + + False + Soma\Soma.Core.dll + + + False + Soma\Soma.Core.IT.MsSql.dll + + + False + Soma\Soma.Core.IT.MsSqlCe.dll + SubSonic\SubSonic.Core.dll @@ -196,6 +223,9 @@ + + + diff --git a/Tests/PerformanceTests.cs b/Tests/PerformanceTests.cs index e96adcf8c4d61dc7a756a1900779aa2ddd1871c3..ef7a82a711510ee99b7549444fba57e921c90657 100644 --- a/Tests/PerformanceTests.cs +++ b/Tests/PerformanceTests.cs @@ -68,6 +68,19 @@ static DataClassesDataContext GetL2SContext() private static Func entityFrameworkCompiled = System.Data.Objects.CompiledQuery.Compile((db, id) => db.Posts.First(p => p.Id == id)); + internal class SomaConfig : Soma.Core.MsSqlConfig + { + public override string ConnectionString + { + get { return Program.connectionString; } + } + + public override void Log(Soma.Core.PreparedStatement preparedStatement) + { + // no op + } + } + public void Run(int iterations) { var tests = new Tests(); @@ -164,6 +177,9 @@ public void Run(int iterations) // IDbCommand ormLiteCmd = Program.GetOpenConnection().CreateCommand(); // tests.Add(id => ormLiteCmd.Select("select * from Posts where Id = {0}", id), "ServiceStack.OrmLite SQL Query"); + // Soma + var somadb = new Soma.Core.Db(new SomaConfig()); + tests.Add(id => somadb.Find(id), "Soma"); // HAND CODED diff --git a/Tests/Program.cs b/Tests/Program.cs index 27f6e74884516a905b573a3e8f2f8db04aa93ca9..572fe1c1bc4b4507563a4b9aa4bfd33a66406c4a 100644 --- a/Tests/Program.cs +++ b/Tests/Program.cs @@ -4,8 +4,10 @@ namespace SqlMapper { + [Soma.Core.Table(Name = "Posts")] class Post { + [Soma.Core.Id(Soma.Core.IdKind.Identity)] public int Id { get; set; } public string Text { get; set; } public DateTime CreationDate { get; set; } diff --git a/Tests/Soma/Soma.Core.IT.MsSql.dll b/Tests/Soma/Soma.Core.IT.MsSql.dll new file mode 100644 index 0000000000000000000000000000000000000000..b582015e1a87b42d1c29af44599b515b4e6c3fff Binary files /dev/null and b/Tests/Soma/Soma.Core.IT.MsSql.dll differ diff --git a/Tests/Soma/Soma.Core.IT.MsSqlCe.dll b/Tests/Soma/Soma.Core.IT.MsSqlCe.dll new file mode 100644 index 0000000000000000000000000000000000000000..c1278300dff00238d6fe47c61525c69de932c6a0 Binary files /dev/null and b/Tests/Soma/Soma.Core.IT.MsSqlCe.dll differ diff --git a/Tests/Soma/Soma.Core.dll b/Tests/Soma/Soma.Core.dll new file mode 100644 index 0000000000000000000000000000000000000000..c1811a70144eac6debea0565c2bbd66fc11031ff Binary files /dev/null and b/Tests/Soma/Soma.Core.dll differ diff --git a/Tests/packages.config b/Tests/packages.config index 47faa017610a05d343443b3115fd5a3f08b87e7f..aafa603ce6a9e7606207b04134354d2a8cb69759 100644 --- a/Tests/packages.config +++ b/Tests/packages.config @@ -1,4 +1,5 @@  + \ No newline at end of file diff --git a/packages/FSPowerPack.Community.2.0.0.0/Content/FSPowerPack_Example.fs.pp b/packages/FSPowerPack.Community.2.0.0.0/Content/FSPowerPack_Example.fs.pp new file mode 100644 index 0000000000000000000000000000000000000000..db4eca2f09d218ea31262e4b1e5a6eac790c798e --- /dev/null +++ b/packages/FSPowerPack.Community.2.0.0.0/Content/FSPowerPack_Example.fs.pp @@ -0,0 +1,7 @@ +module FSPowerPowerExample + +open System + +let v = vector [1.0;1.0;1.0] + vector [2.0;2.0;2.0] // (3.0; 3.0; 3.0) +let c = complex 0.0 1.0 * complex 0.0 1.0 // -1r+0i +let r = (1N/2N) * (1N/3N) // 1/6 \ No newline at end of file diff --git a/packages/FSPowerPack.Community.2.0.0.0/FSPowerPack.Community.2.0.0.0.nupkg b/packages/FSPowerPack.Community.2.0.0.0/FSPowerPack.Community.2.0.0.0.nupkg new file mode 100644 index 0000000000000000000000000000000000000000..84680ed2199975eaf4d83900a1d2d200f7c422e2 Binary files /dev/null and b/packages/FSPowerPack.Community.2.0.0.0/FSPowerPack.Community.2.0.0.0.nupkg differ diff --git a/packages/FSPowerPack.Community.2.0.0.0/Lib/Net20/FSharp.PowerPack.Linq.dll b/packages/FSPowerPack.Community.2.0.0.0/Lib/Net20/FSharp.PowerPack.Linq.dll new file mode 100644 index 0000000000000000000000000000000000000000..b6081b4b1f45022e46adabad1d55ebebf178449e Binary files /dev/null and b/packages/FSPowerPack.Community.2.0.0.0/Lib/Net20/FSharp.PowerPack.Linq.dll differ diff --git a/packages/FSPowerPack.Community.2.0.0.0/Lib/Net20/FSharp.PowerPack.Linq.xml b/packages/FSPowerPack.Community.2.0.0.0/Lib/Net20/FSharp.PowerPack.Linq.xml new file mode 100644 index 0000000000000000000000000000000000000000..594ab5a3cb15157e8be384371287c079b1c7fba7 --- /dev/null +++ b/packages/FSPowerPack.Community.2.0.0.0/Lib/Net20/FSharp.PowerPack.Linq.xml @@ -0,0 +1,367 @@ + + +FSharp.PowerPack.Linq + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Convert the quotation expression to LINQ expression trees + + This operation will only succeed for a subset of quotation expressions. + + Exceptions: InvalidArgumentException will be raised if the input expression is + not in the subset that can be converted to a LINQ expression tree + + + + + + + + Compile the quotation expression by first converting to LINQ expression trees + + Exceptions: InvalidArgumentException will be raised if the input expression is + not in the subset that can be converted to a LINQ expression tree + + + + + Evaluate the quotation expression by first converting to LINQ expression trees + + Exceptions: InvalidArgumentException will be raised if the input expression is + not in the subset that can be converted to a LINQ expression tree + + + + + Compile the quotation expression by first converting to LINQ expression trees + + Exceptions: InvalidArgumentException will be raised if the input expression is + not in the subset that can be converted to a LINQ expression tree + + + + + Compile the quotation expression by first converting to LINQ expression trees + + Exceptions: InvalidArgumentException will be raised if the input expression is + not in the subset that can be converted to a LINQ expression tree + + + + + + + + An intrinsic for compiling <c>&lt;@ x <> y @&gt;</c> to expression trees + + + + + + + + This join operator implements the LINQ GroupJoin operator and the <c>query</c> convertor recognises it as such + + + + + This join operator corresponds to the LINQ Join operator and the <c>query</c> convertor recognises it as such + + + + + When used in queries, this operator corresponds to the LINQ Join operator and the <c>query</c> convertor recognises it as such + + + + + When used in queries, this operator corresponds to the LINQ Max operator and the <c>query</c> convertor recognises it as such + It differs in return type from <c>Seq.maxBy</c> + + + + + When used in queries, this operator corresponds to the LINQ Min operator and the <c>query</c> convertor recognises it as such + It differs in return type from <c>Seq.minBy</c> + + + + + When used in queries, this operator corresponds to the LINQ Contains operator and the <c>query</c> convertor recognises it as such + + + + + Evaluate the quotation expression by first converting to a LINQ expression tree + making use of IQueryable operators and then executing expression tree + + Exceptions: <c>InvalidArgumentException</c> will be raised if the input expression is + not in the subset that can be converted to a LINQ expression tree + + + + + + + + This function should not be called directly. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + A set of types used for implementing quotation conversions. + These are public only because targets of Linq Lambda expressions require them to be so + + + + + This module provides Compile and Eval extension members + for F# quotation values, implemented by translating to LINQ + expression trees and using the LINQ dynamic compiler. + + + + diff --git a/packages/FSPowerPack.Community.2.0.0.0/Lib/Net20/FSharp.PowerPack.Metadata.dll b/packages/FSPowerPack.Community.2.0.0.0/Lib/Net20/FSharp.PowerPack.Metadata.dll new file mode 100644 index 0000000000000000000000000000000000000000..e4ff28c4c8b74896c1fa55638b9fc25a4b0431c5 Binary files /dev/null and b/packages/FSPowerPack.Community.2.0.0.0/Lib/Net20/FSharp.PowerPack.Metadata.dll differ diff --git a/packages/FSPowerPack.Community.2.0.0.0/Lib/Net20/FSharp.PowerPack.Metadata.xml b/packages/FSPowerPack.Community.2.0.0.0/Lib/Net20/FSharp.PowerPack.Metadata.xml new file mode 100644 index 0000000000000000000000000000000000000000..dae6b1cea242ad18183763349a7fdc9d5c2a427e --- /dev/null +++ b/packages/FSPowerPack.Community.2.0.0.0/Lib/Net20/FSharp.PowerPack.Metadata.xml @@ -0,0 +1,15761 @@ + + +FSharp.PowerPack.Metadata + + + + + + + + + + + + + + + + The value '%s' is not accessible from this code location + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:970) + + + + + The union cases or fields of the type '%s' are not accessible from this code location + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:969) + + + + + The union case '%s' is not accessible from this code location + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:971) + + + + + The value or constructor '%s' is not defined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:6) + + + + + The value, namespace, type or module '%s' is not defined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:7) + + + + + The value, constructor, namespace or type '%s' is not defined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:5) + + + + + The type parameter '%s' is not defined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:12) + + + + + The type '%s' is not defined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:9) + + + + + The record label or namespace '%s' is not defined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:10) + + + + + The record label '%s' is not defined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:11) + + + + + The pattern discriminator '%s' is not defined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:13) + + + + + The namespace or module '%s' is not defined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:3) + + + + + The namespace '%s' is not defined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:2) + + + + + The field, constructor or member '%s' is not defined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:4) + + + + + The constructor, module or namespace '%s' is not defined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:8) + + + + + The type '%s' implements 'System.IComparable'. Consider also adding an explicit override for 'Object.Equals' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:179) + + + + + The type '%s' implements 'System.IComparable' explicitly but provides no corresponding override for 'Object.Equals'. An implementation of 'Object.Equals' has been automatically provided, implemented via 'System.IComparable'. Consider implementing the override 'Object.Equals' explicitly + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:180) + + + + + The signature and implementation are not compatible because the respective type parameter counts differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:175) + + + + + The signature and implementation are not compatible because the type parameter '%s' has a constraint of the form %s but the implementation does not. Either remove this constraint from the signature or add it to the implementation. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:178) + + + + + The signature and implementation are not compatible because the declaration of the type parameter '%s' requires a constraint of the form %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:177) + + + + + The signature and implementation are not compatible because the type parameter in the class/signature has a different compile-time requirement to the one in the member/implementation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:176) + + + + + The override for '%s' was ambiguous + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:195) + + + + + The override '%s' implements more than one abstract slot, e.g. '%s' and '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:198) + + + + + No implementations of '%s' had the correct number of arguments and type parameters. The required signature is '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:194) + + + + + No implementation was given for '%s'. Note that all interface members must be implemented and listed under an appropriate 'interface' declaration, e.g. 'interface ... with member ...'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:203) + + + + + No implementation was given for '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:202) + + + + + The interface '%s' is included in multiple explicitly implemented interface types. Add an explicit implementation of this interface. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:200) + + + + + A named argument has been assigned more than one value + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:201) + + + + + More than one override implements '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:196) + + + + + The namespace or module attributes differ between signature and implementation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:192) + + + + + The method '%s' is sealed and cannot be overridden + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:197) + + + + + This method is over-constrained in its type parameters + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:193) + + + + + The member '%s' does not have the correct number of method type parameters. The required signature is '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:205) + + + + + The member '%s' does not have the correct number of arguments. The required signature is '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:204) + + + + + The member '%s' does not have the correct kinds of generic parameters. The required signature is '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:206) + + + + + The member '%s' cannot be used to implement '%s'. The required signature is '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:207) + + + + + Invalid value + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:174) + + + + + The struct, record or union type '%s' has an explicit implementation of 'Object.GetHashCode' or 'Object.Equals'. You must apply the 'CustomEquality' attribute to the type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:181) + + + + + The struct, record or union type '%s' has an explicit implementation of 'Object.GetHashCode'. Consider implementing a matching override for 'Object.Equals(obj)' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:182) + + + + + The struct, record or union type '%s' has an explicit implementation of 'Object.Equals'. Consider implementing a matching override for 'Object.GetHashCode()' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:183) + + + + + Duplicate or redundant interface + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:199) + + + + + The implicit instantiation of a generic construct at or near this point could not be resolved because it could resolve to multiple unrelated types, e.g. '%s' and '%s'. Consider using type annotations to resolve the ambiguity + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:169) + + + + + Could not resolve the ambiguity in the use of a generic construct with an 'unmanaged' constraint at or near this position + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1108) + + + + + Could not resolve the ambiguity inherent in the use of a 'printf'-style format string + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:171) + + + + + Could not resolve the ambiguity inherent in the use of the operator '%s' at or near this program point. Consider using type annotations to resolve the ambiguity. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:170) + + + + + Could not resolve the ambiguity in the use of a generic construct with an 'enum' constraint at or near this position + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:172) + + + + + Could not resolve the ambiguity in the use of a generic construct with a 'delegate' constraint at or near this position + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:173) + + + + + The type '%s' is not accessible from this code location + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:968) + + + + + union case + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:945) + + + + + type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:941) + + + + + property + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:950) + + + + + patvar + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:952) + + + + + and %d other overloads + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:944) + + + + + namespace/module + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:955) + + + + + namespace + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:953) + + + + + module + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:954) + + + + + inherits + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:942) + + + + + implements + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:943) + + + + + Full name + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:940) + + + + + also from %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:957) + + + + + from %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:956) + + + + + field + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:948) + + + + + event + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:949) + + + + + argument + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:951) + + + + + active recognizer + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:947) + + + + + active pattern result + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:946) + + + + + Unexpected TExpr_tchoose + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:981) + + + + + Note: Lambda-lifting optimizations have not been applied because of the use of this local constrained generic function as a first class value. Adding type constraints may resolve this condition. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:982) + + + + + The 'VolatileField' attribute may only be used on 'let' bindings in classes + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:689) + + + + + Volatile fields must be marked 'mutable' and cannot be thread-static + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:746) + + + + + A declaration may only be given a value in a signature if the declaration has the [<Literal>] attribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:744) + + + + + In sequence expressions, multiple results are generated using 'yield!' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:663) + + + + + Character range matches have been removed in F#. Consider using a 'when' pattern guard instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:596) + + + + + Use 'typeof<_>' instead + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:610) + + + + + The use of 'let! x = coll' in sequence expressions is no longer permitted. Use 'for x in coll' instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:661) + + + + + This attribute cannot be used in this version of F# + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:716) + + + + + Unrecognized attribute target. Valid attribute targets are 'assembly', 'module', 'type', 'method', 'property', 'return', 'param', 'field', 'event', 'constructor'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:706) + + + + + Unrecognized accessibility specification + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:508) + + + + + The unnamed arguments do not form a prefix of the arguments of the method called + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:683) + + + + + Unknown union case + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:534) + + + + + Unit-of-measure cannot be used in type constructor application + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:572) + + + + + This union case takes one argument + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:590) + + + + + This union case expects %d arguments in tupled form + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:591) + + + + + This union case does not take arguments + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:589) + + + + + Uninitialized 'val' fields in implicit construction types must be mutable and marked with the '[<DefaultValue>]' attribute. Consider using a 'let' binding instead of a 'val' field. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:747) + + + + + Unexpected type arguments + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:581) + + + + + Unexpected type application + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:664) + + + + + Unexpected %s in type expression + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:575) + + + + + Unexpected / in type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:580) + + + + + Unexpected source-level property specification + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:545) + + + + + Unexpected source-level property specification in syntax tree + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:539) + + + + + Unexpected Measure_Anon + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:494) + + + + + Unexpected expression at recursive inference point + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:524) + + + + + Unexpected constraints or parameters on module specification + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:787) + + + + + Unexpected constraint or type definition + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:788) + + + + + Unexpected Const_uint16array + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:499) + + + + + Unexpected Const_bytearray + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:500) + + + + + Unexpected condition in imported assembly: failed to decode AttributeUsage attribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:705) + + + + + Unexpected big rational constant + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:497) + + + + + The field '%s' has been given a value, but is not present in the type '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:629) + + + + + Unable to parse format string '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:606) + + + + + Types cannot inherit from multiple concrete types + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:797) + + + + + Types cannot contain nested type definitions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:776) + + + + + Struct types are always sealed + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:809) + + + + + Record types are always sealed + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:807) + + + + + Enum types are always sealed + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:811) + + + + + Delegate types are always sealed + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:810) + + + + + Discriminated union types are always sealed + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:806) + + + + + Assembly code types are always sealed + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:808) + + + + + The type '%s' is used in an invalid way. A value prior to '%s' has an inferred type involving '%s', which is an invalid forward reference. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:834) + + + + + This type requires a definition + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:794) + + + + + The type parameters inferred for this value are not stable under the erasure of type abbreviations. This is due to the use of type abbreviations which drop or reorder type parameters, e.g. \n\ttype taggedInt<'a> = int or\n\ttype swap<'a,'b> = 'b * 'a.\nConsider declaring the type parameters for this value explicitly, e.g.\n\tlet f<'a,'b> ((x,y) : swap<'b,'a>) : swap<'a,'b> = (y,x). + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:529) + + + + + Type parameter cannot be used as type constructor + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:576) + + + + + This type parameter has been used in a way that constrains it to always be '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:528) + + + + + This value, type or method expects %d type parameter(s) but was given %d + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:551) + + + + + type or module + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:778) + + + + + The type '%s' is not an interface type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:754) + + + + + This type is not an interface type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:771) + + + + + This type is not a record type. Values of class and struct types must be created using calls to object constructors. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:656) + + + + + This type is not a record type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:657) + + + + + This type is not accessible from this code location + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:704) + + + + + This type has no nested types + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:574) + + + + + This type has no accessible object constructors + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:667) + + + + + Fields which are type functions cannot be mutated + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:492) + + + + + type, exception or module + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:777) + + + + + Type definitions using implicit construction may only have one 'inherit' specification and it must be the first declaration + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:827) + + + + + Type definitions using implicit construction must have local let/do-bindings preceding member and interface definitions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:828) + + + + + This type definition involves an immediate cyclic reference through a struct field or inheritance relation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:823) + + + + + This type definition involves an immediate cyclic reference through an abbreviation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:822) + + + + + The type '%s' is not a type whose values can be enumerated with this syntax, i.e. is not compatible with either seq<_>, IEnumerable<_> or IEnumerable and does not have a GetEnumerator method + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:558) + + + + + Type abbreviations cannot have members + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:761) + + + + + Type abbreviations cannot have interface declarations + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:769) + + + + + Type abbreviations cannot have augmentations + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:832) + + + + + This type abbreviation has one or more declared type parameters that do not appear in the type being abbreviated. Type abbreviations must use all declared type parameters in the type being abbreviated. Consider removing one or more type parameters, or use a concrete type definition that wraps an underlying type, such as 'type C<'a> = C of ...'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:795) + + + + + 'try'/'with' cannot be used within sequence expressions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:662) + + + + + Thread-static and context-static variables must be static and given the [<DefaultValue>] attribute to indicate that the value is initialized to the default value on each new thread + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:745) + + + + + The syntax 'expr.id' may only be used with record labels, properties and fields + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:678) + + + + + Syntax error - unexpected '?' symbol + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:598) + + + + + '%s' may only be used to construct object types + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:627) + + + + + The struct, record or union type '%s' has the 'StructuralEquality' attribute but the component type '%s' does not satisfy the 'equality' constraint + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1085) + + + + + The struct, record or union type '%s' has the 'StructuralEquality' attribute but the type parameter '%s' does not satisfy the 'equality' constraint. Consider adding the 'equality' constraint to the type parameter + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1084) + + + + + The struct, record or union type '%s' has the 'StructuralComparison' attribute but the component type '%s' does not satisfy the 'comparison' constraint + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1079) + + + + + The struct, record or union type '%s' has the 'StructuralComparison' attribute but the type parameter '%s' does not satisfy the 'comparison' constraint. Consider adding the 'comparison' constraint to the type parameter + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1078) + + + + + Each argument of the primary constructor for a struct must be given a type, for example 'type S(x1:int, x2: int) = ...'. These arguments determine the fields of the struct. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1086) + + + + + Structs cannot contain 'let' bindings because the default constructor for structs will not execute these bindings. Consider adding additional arguments to the primary constructor for the type. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:765) + + + + + Structs cannot contain 'do' bindings because the default constructor for structs would not execute these bindings + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:764) + + + + + Structs, interfaces, enums and delegates cannot inherit from other types + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:796) + + + + + Structs cannot have an object constructor with no arguments. This is a restriction imposed on all CLI languages as structs automatically support a default constructor. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:737) + + + + + Structs may only bind a 'this' parameter at member declarations + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:523) + + + + + Struct types cannot contain abstract members + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:816) + + + + + Static 'val' fields in types must be mutable, private and marked with the '[<DefaultValue>]' attribute. They are initialized to the 'null' or 'zero' value for their type. Consider also using a 'static let mutable' binding in a class type. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:748) + + + + + Static optimization conditionals are only for use within the F# library + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:684) + + + + + This static member should not have a 'this' parameter. Consider using the notation 'member Member(args) = ...'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:542) + + + + + Static 'let' bindings may only be defined in class types with implicit constructors + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:766) + + + + + Interfaces cannot contain definitions of static initializers + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:732) + + + + + A static initializer requires an argument + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:540) + + + + + A static field was used where an instance field is expected + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:490) + + + + + A simple method name is required here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:636) + + + + + In sequence expressions, results are generated using 'yield' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:496) + + + + + Return values cannot have names + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:502) + + + + + Return types of union cases must be identical to the type being defined, up to abbreviations + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:752) + + + + + The syntax 'type X with ...' is reserved for augmentations. Types whose representations are hidden but which have members are now declared in signatures using 'type X = ...'. You may also need to add the '[<Sealed>] attribute to the type declaration in the signature + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:824) + + + + + This is not a variable, constant, active recognizer or literal + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:594) + + + + + This control construct may only be used if the computation expression builder defines a '%s' method + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:573) + + + + + Only active patterns returning exactly one result may accept arguments + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:586) + + + + + The representation of this type is hidden by the signature. It must be given an attribute such as [<Sealed>], [<Class>] or [<Interface>] to indicate the characteristics of the type. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:802) + + + + + Recursive bindings that include member specifications can only occur as a direct augmentation of a type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:739) + + + + + Records, union, abbreviations and struct types cannot have the 'AllowNullLiteral' attribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:798) + + + + + This record contains fields from inconsistent types + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:521) + + + + + A property cannot have explicit type parameters. Consider using a method instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:536) + + + + + This property or field was not found on this custom attribute type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:711) + + + + + Property '%s' is static + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:675) + + + + + Property '%s' is not static + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:672) + + + + + Property '%s' is not readable + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:673) + + + + + The property implemented by this default is ambiguous + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:729) + + + + + Property '%s' cannot be set + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:676) + + + + + This property cannot be set + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:710) + + + + + This property already has a default implementation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:728) + + + + + The types System.ValueType, System.Enum, System.Delegate, System.MulticastDelegate and System.Array cannot be used as super types in an object expression or class + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:637) + + + + + A parameter with attributes must also be given a name, e.g. '[<Attribute>] paramName : paramType' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:501) + + + + + The parameter '%s' was inferred to have byref type. Parameters of byref type must be given an explicit type annotation, e.g. 'x1: byref<int>'. When used, a byref parameter is implicitly dereferenced. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1103) + + + + + You must explicitly declare either all or no type parameters when overriding a generic abstract method + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:531) + + + + + Accessibility modifiers are not permitted on overrides or interface implementations + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:805) + + + + + This override takes a different number of arguments to the corresponding abstract member + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:722) + + + + + One or more of the overloads of this method has curried arguments. Consider redesigning these members to take arguments in tupled form. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:682) + + + + + Optional arguments cannot be used in custom attributes + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:709) + + + + + Optional arguments are only permitted on type members + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:582) + + + + + Optional arguments must come at the end of the argument list, after any non-optional arguments + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1122) + + + + + This declaration opens the namespace or module '%s' through a partially qualified path. Adjust this code to use the full path of the namespace. This change will make your code more robust as new constructs are added to the F# and CLI libraries. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:759) + + + + + Only types representing units-of-measure may be given the 'Measure' attribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:804) + + + + + Only structs and classes without implicit constructors may be given the 'StructLayout' attribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:801) + + + + + Only simple variable patterns can be bound in 'let rec' constructs + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:740) + + + + + Only simple bindings of the form 'id = expr' can be used in construction expressions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:643) + + + + + Only record fields and simple 'let' bindings may be marked mutable + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:741) + + + + + Only functions may be marked 'inline' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:698) + + + + + Only classes may be given the 'AbstractClass' attribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:803) + + + + + Objects must be initialized by an object construction expression that calls an inherited object constructor and assigns a value to each field + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:644) + + + + + The operator 'expr.[idx]' has been used an object of indeterminate type based on information prior to this program point. Consider adding further type constraints + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:618) + + + + + Only overrides of abstract and virtual members may be specified in object expressions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:632) + + + + + This form of object expression is not used in F#. Use 'member this.MemberName ... = ...' to define member implementations in object expressions. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:546) + + + + + Calls to object constructors on type parameters cannot be given arguments + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:620) + + + + + Interfaces cannot contain definitions of object constructors + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:733) + + + + + An object constructor requires an argument + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:541) + + + + + Object construction expressions (i.e. record expressions with inheritance specifications) may only be used to implement constructors in object model types. Use 'new ObjectType(args)' to construct instances of object model types outside of constructors + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:654) + + + + + Object construction expressions may only be used to implement constructors in class types + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:642) + + + + + This numeric literal requires that a module '%s' defining functions FromZero, FromOne, FromInt32, FromInt64 and FromString be in scope + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:650) + + + + + This is not a valid name for an enumeration case + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:611) + + + + + This code is not sufficiently generic. The type variable %s could not be generalized because it would escape its scope. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:535) + + + + + Not an exception + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:786) + + + + + Non-zero constants cannot have generic units. For generic zero, write 0.0<_>. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:495) + + + + + The generic member '%s' has been used at a non-uniform instantiation prior to this program point. Consider reordering the members so this member occurs first. Alternatively, specify the full type of the member explicitly, including argument types, return type and any additional generic parameters and constraints. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1104) + + + + + This value is not a literal and cannot be used in a pattern + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:554) + + + + + No abstract property was found that corresponds to this override + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:725) + + + + + No abstract or interface member was found that corresponds to this override + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:721) + + + + + Interface implementations cannot be given on construction expressions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:641) + + + + + The struct, record or union type '%s' does not support structural equality because the type '%s' does not satisfy the 'equality' constraint. Consider adding the 'NoEquality' attribute to the type '%s' to clarify that the type does not support structural equality + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1083) + + + + + The struct, record or union type '%s' does not support structural equality because the type parameter %s does not satisfy the 'equality' constraint. Consider adding the 'NoEquality' attribute to the type '%s' to clarify that the type does not support structural equality + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1082) + + + + + The struct, record or union type '%s' is not structurally comparable because the type '%s' does not satisfy the 'comparison' constraint. Consider adding the 'NoComparison' attribute to the type '%s' to clarify that the type is not comparable + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1081) + + + + + The struct, record or union type '%s' is not structurally comparable because the type parameter %s does not satisfy the 'comparison' constraint. Consider adding the 'NoComparison' attribute to the type '%s' to clarify that the type is not comparable + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1080) + + + + + No arguments may be given when constructing a record value + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:640) + + + + + The member '%s' does not correspond to any abstract or virtual method available to override or implement + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:633) + + + + + 'new' may only be used with object constructors + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:648) + + + + + 'new' must be used with a named type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:638) + + + + + This new member hides the abstract member '%s' once tuples, functions and/or units of measure are erased. Rename the member or use 'override' instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:731) + + + + + This new member hides the abstract member '%s'. Rename the member or use 'override' instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:730) + + + + + 'new' cannot be used on interface types. Consider using an object expression '{ new ... with ... }' instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:624) + + + + + Namespaces cannot contain values. Consider using a module to hold your value declarations. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:504) + + + + + Namespaces cannot contain extension members except in the same file and namespace where the type is defined. Consider using a module to hold declarations of extension members. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:505) + + + + + '%s' may only be used with named types + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:622) + + + + + The use of named arguments in union case expressions is reserved for future use. Arguments of the form 'a=b' should be parenthesized. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1105) + + + + + Named arguments cannot be given to member trait calls + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:609) + + + + + The named argument '%s' did not match any argument or mutable property + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:681) + + + + + Name '%s' not bound in pattern context + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:583) + + + + + Named arguments must appear after all other arguments + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:556) + + + + + Mutable function values should be written 'let mutable f = (fun args -> ...)' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:697) + + + + + Mutable values cannot have generic parameters + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:696) + + + + + Mutable values cannot be marked 'inline' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:695) + + + + + Multiple visibility attributes have been specified for this identifier. 'let' bindings in classes are always private, as are any 'let' bindings inside expressions. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:507) + + + + + Multiple visibility attributes have been specified for this identifier + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:506) + + + + + Modules cannot use named module signature definitions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:837) + + + + + This declaration opens the module '%s', which is marked as 'RequireQualifiedAccess'. Adjust your code to use qualified references to the elements of the module instead, e.g. 'List.map' instead of 'map'. This change will ensure that your code is robust as new constructs are added to libraries. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:758) + + + + + The path '%s' is a namespace. A module abbreviation may not abbreviate a namespace. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:833) + + + + + Method overrides and interface implementations are not permitted here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:720) + + + + + Method '%s' is not accessible from this code location + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:491) + + + + + Members that extend interface, delegate or enum types must be placed in a module separate to the definition of the type. This module must either have the AutoOpen attribute or be opened explicitly by client code to bring the extension members into scope. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:825) + + + + + The member '%s' is used in an invalid way. A use of '%s' has been inferred prior to the definition of '%s', which is an invalid forward reference. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:835) + + + + + Interfaces cannot contain definitions of member overrides + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:734) + + + + + Extension members cannot provide operator overloads. Consider defining the operator as part of the type definition instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1125) + + + + + This member is not permitted in an interface implementation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:774) + + + + + MemberKindPropertyGetSet only expected in parse trees + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:503) + + + + + This member is not sufficiently generic + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:742) + + + + + A member and a local class binding both have the name '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:768) + + + + + Measure definitions cannot have type parameters + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:793) + + + + + Measure declarations may have only static members: constructors are not available + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:767) + + + + + Measure declarations may have only static members + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:763) + + + + + This lookup cannot be used here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:674) + + + + + Local class bindings cannot be marked inline. Consider lifting the definition out of the class or else do not mark it as inline. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:760) + + + + + Literal values cannot have generic parameters + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:702) + + + + + A literal value cannot be marked 'mutable' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:700) + + + + + A literal value cannot be marked 'inline' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:701) + + + + + A declaration may only be the [<Literal>] attribute if a constant value is also given, e.g. 'val x : int = 1' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:743) + + + + + This list expression exceeds the maximum size for list literals. Use an array for larger literals and call Array.ToList. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:607) + + + + + 'let' and 'do' bindings are not permitted in class definitions unless an implicit construction sequence is used. You can use an implicit construction sequence by modifying the type declaration to include arguments, e.g. 'type X(args) = ...'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:831) + + + + + This code is less generic than required by its annotations because the explicit type variable '%s' could not be generalized. It was constrained to be '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:525) + + + + + The kind of the type specified by its attributes does not match the kind implied by its definition + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:792) + + + + + Invalid use of a type name and/or object constructor. If necessary use 'new' and apply the constructor to its arguments, e.g. 'new Type(args)'. Overloads are:\n\t%s. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:669) + + + + + Invalid use of a type name and/or object constructor. If necessary use 'new' and apply the constructor to its arguments, e.g. 'new Type(args)'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:668) + + + + + Invalid use of a type name + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:666) + + + + + Invalid use of an interface type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:670) + + + + + Invalid use of a delegate constructor. Use the syntax 'new Type(args)' or just 'Type(args)'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:671) + + + + + The 'UseNullAsTrueValue' attribute flag may only be used with union types that have one nullary case and at least one non-nullary case + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1102) + + + + + 'use' bindings must be of the form 'use <var> = <expr>' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:718) + + + + + Units-of-measure cannot be used as prefix arguments to a type. Rewrite as postfix arguments in angle brackets. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:571) + + + + + Units-of-measure supported only on float, float32, decimal and signed integer types + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:498) + + + + + Literal enumerations must have type int, uint, int16, uint16, int64, uint64, byte, sbyte or char + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:820) + + + + + Invalid type extension + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:790) + + + + + Type arguments cannot be specified here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:585) + + + + + Invalid signature for set member + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:727) + + + + + Invalid record, sequence or computation expression. Sequence expressions should be of the form 'seq { ... }' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:604) + + + + + Invalid record construction + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:651) + + + + + This property has an invalid type. Properties taking multiple indexer arguments should have types of the form 'ty1 * ty2 -> ty3'. Properties returning functions should have types of the form '(ty1 -> ty2)'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:566) + + + + + This is not a valid pattern + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:595) + + + + + Invalid optional assignment to a property or field + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:686) + + + + + The '%s' operator should not normally be redefined. To define overloaded comparison semantics for a particular type, implement the 'System.IComparable' interface in the definition of that type. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:513) + + + + + The '%s' operator should not normally be redefined. To define equality semantics for a type, override the 'Object.Equals' member in the definition of that type. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:514) + + + + + The '%s' operator should not normally be redefined. Consider using a different operator name + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:515) + + + + + Invalid object, sequence or record expression + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:603) + + + + + Invalid object expression. Objects without overrides or interfaces should use the expression form 'new Type(args)' without braces. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:602) + + + + + This is not a valid object construction expression. Explicit object constructors must either call an alternate constructor or initialize all fields of the object and specify a call to a super class constructor. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:561) + + + + + Non-primitive numeric literal constants cannot be used in pattern matches because they can be mapped to multiple different types through the use of a NumericLiteral module. Consider using replacing with a variable, and use 'when <variable> = <constant>' at the end of the match clause. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:584) + + + + + 'new' constraints must take one argument of type 'unit' and return the constructed type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:565) + + + + + Invalid namespace, module, type or union case name + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:750) + + + + + Invalid module name + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:789) + + + + + This recursive binding uses an invalid mixture of recursive forms + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:560) + + + + + The name '(%s)' should not be used as a member name. To define comparison semantics for a type, implement the 'System.IComparable' interface. If defining a static member for use from other CLI languages then use the name '%s' instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:509) + + + + + The name '(%s)' should not be used as a member name. To define equality semantics for a type, override the 'Object.Equals' member. If defining a static member for use from other CLI languages then use the name '%s' instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:510) + + + + + The name '(%s)' should not be used as a member name because it is given a standard definition in the F# library over fixed types + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:512) + + + + + The name '(%s)' should not be used as a member name. If defining a static member for use from other CLI languages then use the name '%s' instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:511) + + + + + Invalid inline specification + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:717) + + + + + Invalid indexer expression + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:617) + + + + + The '%s' operator cannot be redefined. Consider using a different operator name + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:516) + + + + + Internal error. Invalid index into active pattern array + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:588) + + + + + This is not a valid value for an enumeration literal + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:753) + + + + + An 'enum' constraint must be of the form 'enum<type>' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:564) + + + + + Delegate specifications must be of the form 'typ -> typ' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:818) + + + + + Invalid declaration + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:547) + + + + + Invalid constraint: the type used for the constraint is sealed, which means the constraint could only be satisfied by at most one solution + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:563) + + + + + Invalid constraint + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:562) + + + + + This is not a valid constant expression + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:703) + + + + + Invalid assignment + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:665) + + + + + Invalid argument to parameterized pattern label + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:587) + + + + + This is not a valid name for an active pattern + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:693) + + + + + Interfaces inherited by other interfaces should be declared using 'inherit ...' instead of 'interface ...' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1114) + + + + + Interface types cannot be sealed + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:817) + + + + + Interface types and delegate types cannot contain fields + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:812) + + + + + This instance member needs a parameter to represent the object being invoked. Make the member static or use the notation 'member x.Member(args) = ...'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:538) + + + + + The inherited type is not an object model type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:653) + + + + + A inheritance declaration is not permitted here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:757) + + + + + This 'inherit' declaration specifies the inherited type but no arguments. Consider supplying arguments, e.g. 'inherit BaseType(args)'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:829) + + + + + This 'inherit' construction call is not part of an implicit construction sequence. Only the inherited type should be specified at this point. Calls to the inherited constructor should be placed inside the object initialization expression of your object constructor. Alternatively use an implicit construction sequence by modifying the type declaration to include arguments, e.g. 'type X(args) = ...'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:830) + + + + + 'inherit' cannot be used on interface types. Consider implementing the interface by using 'interface ... with ... end' instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:623) + + + + + Implicit product of measures following / + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:493) + + + + + The struct, record or union type '%s' implements the interface 'System.IStructuralEquatable' explicitly. Apply the 'CustomEquality' attribute to the type. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:779) + + + + + The struct, record or union type '%s' implements the interface 'System.IStructuralComparable' explicitly. Apply the 'CustomComparison' attribute to the type. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:520) + + + + + The struct, record or union type '%s' implements the interface 'System.IEquatable<_>' explicitly. Apply the 'CustomEquality' attribute to the type and provide a consistent implementation of the non-generic override 'System.Object.Equals(obj)'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:780) + + + + + The struct, record or union type '%s' implements the interface 'System.IComparable' explicitly. You must apply the 'CustomComparison' attribute to the type. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:518) + + + + + The struct, record or union type '%s' implements the interface 'System.IComparable<_>' explicitly. You must apply the 'CustomComparison' attribute to the type, and should also provide a consistent implementation of the non-generic interface System.IComparable. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:519) + + + + + Illegal syntax in type expression + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:577) + + + + + Illegal pattern + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:597) + + + + + Explicit type declarations for constructors must be of the form 'ty1 * ... * tyN -> resTy'. Parentheses may be required around 'resTy' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:751) + + + + + A literal value cannot be given the [<ThreadStatic>] or [<ContextStatic>] attributes + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:699) + + + + + It is recommended that objects that support the IDisposable interface are created using 'new Type(args)' rather than 'Type(args)' to indicate that resources may be owned by the generated value + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:626) + + + + + Generic types cannot be given the 'StructLayout' attribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:800) + + + + + A generic type parameter has been used in a way that constrains it to always be '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:527) + + + + + The generic function '%s' must be given explicit type argument(s) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:549) + + + + + This function value is being used to construct a delegate type whose signature includes a byref argument. You must use an explicit lambda expression taking %d arguments. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:557) + + + + + The corresponding formal argument is not optional + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:685) + + + + + The field labels and expected type of this record expression or pattern do not uniquely determine a corresponding record type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:532) + + + + + A field/val declaration is not permitted here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:756) + + + + + This field requires a name + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:749) + + + + + No assignment given for field '%s' of type '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:630) + + + + + This field is not a literal and cannot be used in a pattern + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:593) + + + + + This field is readonly + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:555) + + + + + Field '%s' is not static + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:592) + + + + + This field is not mutable + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:612) + + + + + The field '%s' appears twice in this record expression or pattern + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:533) + + + + + All record, union and struct types in FSharp.Core.dll must be explicitly labelled with 'StructuralComparison' or 'NoComparison' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1077) + + + + + Extraneous fields have been given values + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:631) + + + + + This list or array expression includes an element of the form 'if ... then ... else'. Parenthesize this expression to indicate it is an individual element of the list or array, to disambiguate this from a list generated using a sequence expression + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:605) + + + + + This expression form may only be used in sequence and computation expressions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:601) + + + + + The expression form { expr with ... } may only be used with record types. To build object types use { new Type(...) with ... } + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:652) + + + + + The expression form 'expr then expr' may only be used as part of an explicit object constructor + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:608) + + + + + Expected %d expressions, got %d + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:599) + + + + + TcExprUndelayed: delayed + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:600) + + + + + Explicit type specifications cannot be used for exception constructors + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:781) + + + + + Explicit type parameters may only be used on module or member bindings + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:530) + + + + + An explicit static initializer should use the syntax 'static new(args) = expr' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:543) + + + + + Explicit signatures within implementation files may no longer be used + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:836) + + + + + An explicit object constructor should use the syntax 'new(args) = expr' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:544) + + + + + Expected unit-of-measure, not type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:570) + + + + + Expected unit-of-measure parameter, not type parameter. Explicit unit-of-measure parameters must be marked with the [<Measure>] attribute. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:567) + + + + + Expected type parameter, not unit-of-measure parameter + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:568) + + + + + Expected type, not unit-of-measure + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:569) + + + + + Expected an interface type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:645) + + + + + Expected module or namespace parent %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:517) + + + + + Exception abbreviations should not have argument lists + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:782) + + + + + Exception abbreviations must refer to existing exceptions or F# types deriving from System.Exception + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:784) + + + + + Event '%s' is static + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:679) + + + + + Event '%s' is not static + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:680) + + + + + Enumerations cannot have members + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:762) + + + + + Enumerations cannot have interface declarations + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:770) + + + + + The 'EntryPointAttribute' attribute may only be used on function definitions in modules + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:694) + + + + + '{ }' is not a valid expression. Records must include at least one field. Empty sequences are specified by using Seq.empty or an empty list '[]'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:655) + + + + + Duplicate specification of an interface + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:755) + + + + + The method or function '%s' should not be given explicit type argument(s) because it does not declare its type parameters explicitly + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:550) + + + + + 'do!' cannot be used within sequence expressions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:660) + + + + + DLLImport stubs cannot be inlined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:522) + + + + + Delegate specifications must not be curried types. Use 'typ * ... * typ -> typ' for multi-argument delegates, and 'typ -> (typ -> typ)' for delegates returning function values. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:819) + + + + + A delegate constructor must be passed a single function value + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:687) + + + + + The 'DefaultValue' attribute may only be used on 'val' declarations + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:691) + + + + + The default, zero-initializing constructor of a struct type may only be used if all the fields of the struct type admit default initialization + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:552) + + + + + A default implementation of this interface has already been added because the explicit implementation of the interface was not specified at the definition of the type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:773) + + + + + This method already has a default implementation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:723) + + + + + The method implemented by this default is ambiguous + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:724) + + + + + The declared type parameters for this type extension do not match the declared type parameters on the original type '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:826) + + + + + This declaration element is not permitted in an augmentation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:775) + + + + + A custom attribute must invoke an object constructor + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:714) + + + + + A custom attribute must be a reference type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:712) + + + + + The number of args for a custom attribute does not match the expected number of args for the attribute constructor + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:713) + + + + + Couldn't find Dispose on IDisposable, or it was overloaded + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:553) + + + + + Constructors cannot be defined for this type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:738) + + + + + Constructors cannot be specified in exception augmentations + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:736) + + + + + Constructors must be applied to arguments and cannot be used as first-class values. If necessary use an anonymous function '(fun arg1 ... argN -> new Type(arg1,...,argN))'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:677) + + + + + Constructors for the type '%s' must directly or indirectly call its implicit object constructor. Use a call to the implicit object constructor instead of a record expression. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:628) + + + + + This object constructor requires arguments + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:647) + + + + + Constructor expressions for interfaces do not take arguments + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:646) + + + + + A constructor cannot have explicit type parameters. Consider using a static construction method instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:537) + + + + + This construct may only be used within sequence or computation expressions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:615) + + + + + This construct may only be used within list, array and sequence expressions, e.g. expressions of the form 'seq { ... }', '[ ... ]' or '[| ... |]'. These use the syntax 'for ... in ... do ... yield...' to generate elements + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:613) + + + + + This construct may only be used within computation expressions. To return a value from an ordinary function simply write the expression without 'return'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:614) + + + + + This construct may only be used within computation expressions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:616) + + + + + This construct is ambiguous as part of a sequence expression. Nested expressions may be written using 'let _ = (...)' and nested sequences using 'yield! seq {... }'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:659) + + + + + This construct is ambiguous as part of a computation expression. Nested expressions may be written using 'let _ = (...)' and nested computations using 'let! res = builder { ... }'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:658) + + + + + One or more of the explicit class or function type variables for this binding could not be generalized, because they were constrained to other types + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:526) + + + + + Attribute 'System.Diagnostics.ConditionalAttribute' is only valid on methods or attribute classes + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1123) + + + + + The 'ConditionalAttribute' attribute may only be used on members + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:692) + + + + + Interfaces cannot contain definitions of concrete members. You may need to define a constructor on your type, or use implicit class construction, to indicate that the type is a concrete implementation class. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:735) + + + + + The 'CompiledName' attribute cannot be used with this language element + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:621) + + + + + Cannot inherit from a variable type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:619) + + + + + Cannot inherit a sealed type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:814) + + + + + Cannot inherit from interface type. Use interface ... with instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:815) + + + + + Cannot create an extension of a sealed type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:639) + + + + + Cannot call an abstract base member: '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1107) + + + + + A binding cannot be marked both 'use' and 'rec' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:688) + + + + + This expression has a method called GetEnumerator, but its return type is a value type. Methods returning struct enumerators cannot be used in this expression form. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:559) + + + + + The attributes of this type specify multiple kinds for the type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:791) + + + + + Attributes are not allowed within patterns + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:548) + + + + + Attributes are not permitted on 'let' bindings in expressions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:690) + + + + + This attribute is not valid for use on this language element. Assembly attributes should be attached to a 'do ()' declaration, if necessary within an F# module. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:707) + + + + + This attribute is not valid for use on this language element + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:708) + + + + + Attribute expressions must be calls to object constructors + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:715) + + + + + The attribute 'AutoOpen(\"%s\")' in the assembly '%s' did not refer to a valid module or namespace in that assembly and has been ignored + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:838) + + + + + The attribute '%s' appears in both the implementation and the signature, but the attribute arguments differ. Only the attribute from the signature will be included in the compiled code. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1106) + + + + + At least one override did not correctly implement its corresponding abstract member + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:649) + + + + + The member '%s' does not accept the correct number of arguments. One overload accepts %d arguments. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:635) + + + + + The member '%s' does not accept the correct number of arguments, %d arguments are expected + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:634) + + + + + Anonymous unit-of-measure cannot be nested inside another unit-of-measure expression + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:578) + + + + + Anonymous type variables are not permitted in this declaration + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:579) + + + + + Types with the 'AllowNullLiteral' attribute may only inherit from or implement types which also allow the use of the null literal + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:799) + + + + + All implemented interfaces should be declared on the initial declaration of the type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:772) + + + + + Instances of this type cannot be created since it has been marked abstract or not all methods have been given implementations. Consider using an object expression '{ new ... with ... }' instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:625) + + + + + This property overrides or implements an abstract property but the abstract property doesn't have a corresponding %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:726) + + + + + Abstract members are not permitted in an augmentation - they must be defined as part of the type itself + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:719) + + + + + Abbreviations for Common IL exception types must have a matching object constructor + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:785) + + + + + Abbreviations for Common IL exceptions cannot take arguments + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:783) + + + + + Abbreviated types cannot be given the 'Sealed' attribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:813) + + + + + A value must be mutable in order to mutate the contents or take the address of a value type, e.g. 'let mutable x = ...' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:88) + + + + + The value has been copied to ensure the original is not mutated by this operation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:90) + + + + + This value does not have a valid property setter type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:84) + + + + + Unexpected decode of InternalsVisibleToAttribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:95) + + + + + Unexpected decode of InterfaceDataVersionAttribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:96) + + + + + Unexpected decode of AutoOpenAttribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:94) + + + + + Unexpected use of a byref-typed variable + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:87) + + + + + The type %s did not contain the union case '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1098) + + + + + The type %s did not contain the field '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1097) + + + + + The module/namespace '%s' from compilation unit '%s' did not contain the val '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1100) + + + + + The module/namespace '%s' from compilation unit '%s' did not contain the namespace, module or type '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1101) + + + + + The module/namespace '%s' from compilation unit '%s' did not contain the module/namespace '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1099) + + + + + The type/module '%s' is not a concrete module or type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:74) + + + + + The type '%s' has an inline assembly code representation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:75) + + + + + Two modules named '%s' occur in two parts of this assembly + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:77) + + + + + Recursively defined values cannot appear directly as part of the construction of a tuple value within a recursive binding + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:91) + + + + + Recursive values cannot be directly assigned to the non-mutable field '%s' of the type '%s' within a recursive binding. Consider using a mutable field instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:93) + + + + + Recursive values cannot appear directly as a construction of the type '%s' within a recursive binding. This feature has been removed from the F# language. Consider using a record instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:92) + + + + + This is not a constant expression or valid custom attribute value + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:99) + + + + + A namespace and a module named '%s' both occur in two parts of this assembly + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:76) + + + + + Invalid mutation of a constant expression. Consider copying the expression to a mutable local, e.g. 'let mutable x = ...'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:89) + + + + + Invalid member signature encountered because of an earlier error + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:83) + + + + + Invalid form for a property setter. At least one argument is required. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:86) + + + + + Invalid form for a property getter. At least one '()' argument is required when using the explicit syntax. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:85) + + + + + This operation accesses a mutable top-level value defined in another assembly in an unsupported way. The value cannot be accessed through its address. Consider copying the expression to a mutable local, e.g. 'let mutable x = ...', and if necessary assigning the value back after the completion of the operation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1093) + + + + + Two type definitions named '%s' occur in namespace '%s' in two parts of this assembly + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:78) + + + + + This constant cannot be used as a custom attribute value + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:98) + + + + + A module and a type definition named '%s' occur in namespace '%s' in two parts of this assembly + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:79) + + + + + Active patterns cannot return more than 7 possibilities + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:97) + + + + + The struct or class field '%s' is not accessible from this code location + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:973) + + + + + If set to true, then all error messages will just return the filled 'holes' delimited by ',,,'s - this is for language-neutral testing (e.g. localization-invariant baselines). + + + + + Recursive class hierarchy in type '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:965) + + + + + Error reading/writing metadata for the F# compiled DLL '%s'. Was the DLL compiled with an earlier version of the F# compiler? (error: '%s'). + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:70) + + + + + Partial active patterns may only generate one result + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:992) + + + + + Missing variable '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:991) + + + + + Accessibility modifiers are not permitted on an 'inherits' declaration + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:436) + + + + + Accessibility modifiers should come immediately prior to the identifier naming a construct + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:407) + + + + + 'use' bindings are not permitted in modules and are treated as 'let' bindings + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:400) + + + + + 'use' bindings are not permitted in implicit class constructors + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:399) + + + + + Unmatched 'with' or badly formatted 'with' block + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:423) + + + + + Unmatched '(' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:450) + + + + + No body found for this 'let' or 'do'. The body must be indented to the same column as this line. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:449) + + + + + Unmatched 'if' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:455) + + + + + Unmatched 'class', 'interface' or 'struct' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:421) + + + + + Unmatched '[|' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:469) + + + + + Unmatched '[' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:464) + + + + + Unmatched '{' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:470) + + + + + Unmatched 'begin' or 'struct' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:414) + + + + + Unmatched 'begin' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:426) + + + + + Unmatched '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:468) + + + + + Accessibility modifiers are not permitted on union cases. Use 'type U = internal ...' or 'type U = private ...' to give an accessibility to the whole representation. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:444) + + + + + Accessibility modifiers are not permitted here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:405) + + + + + Syntax error: unexpected type parameter specification + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:481) + + + + + A semicolon is not expected at this point + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:403) + + + + + Unexpected infix operator in unit-of-measure expression. Legal operators are '*', '/' and '^'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:479) + + + + + Unexpected integer literal in unit-of-measure expression + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:480) + + + + + Unexpected integer literal in type expression + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:478) + + + + + Unexpected infix operator in type expression + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:476) + + + + + Unexpected identifier: '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:443) + + + + + Unexpected end of input + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:404) + + + + + Unexpected empty type moduleDefn list + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:416) + + + + + Unclosed 'for', e.g. no 'done' found to match this 'for' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:459) + + + + + Unclosed block + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:413) + + + + + Type annotations on property getters and setters must be given after the 'get()' or 'set(v)', e.g. 'with get() : string = ...' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:429) + + + + + Accessibility modifiers are not permitted in this position for type abbreviations + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:439) + + + + + The syntax 'module ... = struct .. end' is not used in F# code. Consider using 'module ... = begin .. end' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:485) + + + + + The syntax 'module ... : sig .. end' is not used in F# code. Consider using 'module ... = begin .. end' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:486) + + + + + Syntax error in labelled type argument + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:475) + + + + + Syntax error + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:419) + + + + + Successive patterns should be separated by spaces or tupled + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:451) + + + + + Successive arguments should be separated by spaces or tupled, and arguments involving function or method applications should be parenthesized + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:463) + + + + + A setter property may have at most two argument groups + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1090) + + + + + Property setters must be defined using 'set value = ', 'set idx value = ' or 'set (idx1,...,idxN) value = ... ' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:432) + + + + + Accessibility modifiers are not permitted on record fields. Use 'type R = internal ...' or 'type R = private ...' to give an accessibility to the whole representation. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:447) + + + + + In F# code you may use 'expr.[expr]'. A type annotation may be required to indicate the first expression is an array + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:466) + + + + + At most one 'with' augmentation is permitted + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:402) + + + + + Only '#' compiler directives may occur prior to the first 'namespace' declaration + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:406) + + + + + Only class types may take value arguments + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:425) + + + + + The use of the type syntax 'int C' and 'C <int>' is not permitted here. Consider adjusting this type to be written in the form 'C<int>' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1096) + + + + + Type parameters must be placed directly adjacent to the type name, e.g. \"type C<'T>\", not type \"C <'T>\" + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1094) + + + + + Type arguments must be placed directly adjacent to the type name, e.g. \"C<'T>\", not \"C <'T>\" + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1095) + + + + + No matching 'in' found for this 'let' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:452) + + + + + No #endif found for #if or #else + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:397) + + + + + No '=' symbol should follow a 'namespace' declaration + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:484) + + + + + Files should begin with either a namespace or module declaration, e.g. 'namespace SomeNamespace.SubNamespace' or 'module SomeNamespace.SomeModule', but not both. To define a module within a namespace use 'module SomeModule = ...' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:408) + + + + + Multiple accessibilities given for property getter or setter + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:431) + + + + + The syntax '(typ,...,typ) ident' is not used in F# code. Consider using 'ident<typ,...,typ>' instead + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:477) + + + + + A module name must be a simple name, not a path + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:415) + + + + + A module abbreviation must be a simple name, not a path + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:409) + + + + + Missing qualification after '.' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:465) + + + + + Missing function body + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:473) + + + + + Mismatched quotation, beginning with '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:467) + + + + + Mismatched quotation operator name, beginning with '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:482) + + + + + This member is not permitted in an object implementation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:472) + + + + + The declaration form 'let ... and ...' for non-recursive bindings is not used in F# code. Consider using a sequence of 'let' bindings + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:448) + + + + + Invalid property getter or setter + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1091) + + + + + Invalid operator definition. Prefix operator definitions must use a valid prefix operator name. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1116) + + + + + Invalid prefix operator + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1115) + + + + + Invalid declaration syntax + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:427) + + + + + Interfaces always have the same visibility as the enclosing type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:433) + + + + + An integer for loop must use a simple identifier + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:401) + + + + + Accessibility modifiers are not permitted on inline assembly code types + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:442) + + + + + 'inherit' declarations cannot have 'as' bindings. To access members of the base class when overriding a method, the syntax 'base.SomeMember' may be used; 'base' is a keyword. Remove this 'as' binding. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:437) + + + + + An indexer property must be given at least one argument + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1092) + + + + + Ignoring visibility attribute on module abbreviation. Module abbreviations are always private. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:412) + + + + + Ignoring accessibility attribute on module abbreviation. Module abbreviations are always private. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:411) + + + + + Ignoring attributes on module abbreviation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:410) + + + + + Identifier expected + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:460) + + + + + A getter property is expected to be a function, e.g. 'get() = ...' or 'get(index) = ...' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:430) + + + + + A getter property may have at most one argument group + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1089) + + + + + 'get', 'set' or 'get,set' required + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:424) + + + + + 'get' and/or 'set' required + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:428) + + + + + Field bindings must have the form 'id = expr;' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:471) + + + + + Block following this '%s' is unfinished. Expect an expression. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:454) + + + + + Error in the return expression for this 'let'. Possible incorrect indentation. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:453) + + + + + Error in 'function' block + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:474) + + + + + '=' expected + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:461) + + + + + End of file in verbatim string embedded in comment begun at or before here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:394) + + + + + End of file in verbatim string begun at or before here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:391) + + + + + End of file in string embedded in comment begun at or before here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:393) + + + + + End of file in string begun at or before here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:390) + + + + + End of file in IF-OCAML section begun at or before here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:395) + + + + + End of file in #if section begun at or after here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:389) + + + + + End of file in directive begun at or before here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:396) + + + + + End of file in comment begun at or before here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:392) + + + + + Accessibility modifiers are not permitted in this position for enum types + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:440) + + + + + Accessibility modifiers are not permitted on enumeration fields + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:445) + + + + + A type definition requires one or more members or other declarations. If you intend to define an empty class, struct or interface, then use 'type ... = class end', 'interface end' or 'struct end'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:422) + + + + + 'done' expected after this expression + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:457) + + + + + 'do' expected after this expression + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:458) + + + + + Accessibility modifiers are not permitted on 'do' bindings + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:388) + + + + + Consider using a separate record type instead + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:446) + + + + + Augmentations are not permitted on delegate type moduleDefns + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:420) + + + + + Attributes should be placed before 'val' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:417) + + + + + Attributes are not permitted on 'inherit' declarations + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:435) + + + + + Attributes are not allowed here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:438) + + + + + Attributes have been ignored in this construct + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:398) + + + + + Attributes are not permitted on interface implementations + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:418) + + + + + 'assert' may no longer be used as a first class value. Use 'assert <expr>' instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:456) + + + + + The use of '->' in sequence and computation expressions is limited to the form 'for pat in expr -> expr'. Use the syntax 'for ... in ... do ... yield...' to generate elements in more complex sequence expressions. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:462) + + + + + All enum fields must be given values + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:441) + + + + + Active pattern case identifiers must begin with an uppercase letter + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:483) + + + + + Accessibility modifiers are not allowed on this member. Abstract slots always have the same visibility as the enclosing type. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:434) + + + + + Write the xmldoc of the assembly to the given file + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:876) + + + + + Specify a Win32 resource file (.res) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:884) + + + + + Specify a Win32 manifest file + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:885) + + + + + Report all warnings as errors + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:894) + + + + + Report specific warnings as errors + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:895) + + + + + Set a warning level (0-4) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:896) + + + + + Output messages in UTF-8 encoding + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:904) + + + + + Unrecognized target '%s', expected 'exe', 'winexe', 'library' or 'module' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:913) + + + + + Unrecognized debug type '%s', expected 'pdbonly' or 'full' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:914) + + + + + Unrecognized platform '%s', valid values are 'x86', 'x64', 'Itanium', and 'anycpu' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:928) + + + + + Unknown --test argument: '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:927) + + + + + Enable or disable tailcalls + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:892) + + + + + Specify a strong name key file + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:877) + + + + + Specify a strong name key container + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:878) + + + + + Statically link the given assembly and all referenced DLLs that depend on this assembly. Use an assembly name e.g. mylib, not a DLL name. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:910) + + + + + Statically link the F# library and all referenced DLLs that depend on it into the assembly being generated + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:909) + + + + + Resolve assembly references using directory-based mono rules rather than MSBuild resolution (Default=false except when running fsc.exe under mono) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:912) + + + + + Print the inferred interface of the assembly to a file + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:882) + + + + + Short form of '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:916) + + + + + Embed the specified managed resource + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:887) + + + + + Reference an assembly (Short form: -r) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:883) + + + + + Problem with codepage '%d': %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:868) + + + + + Limit which platforms this code can run on: x86, Itanium, x64 or anycpu. The default is anycpu. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:879) + + + + + Name the output debug file + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:911) + + + + + Enable optimizations (Short form: -O) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:891) + + + + + Do not include the default Win32 manifest + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:886) + + + + + Disable specific warning messages + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:897) + + + + + Suppress compiler copyright message + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:901) + + + + + Do not reference the default CLI assemblies by default + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:908) + + + + + Only include optimization information essential for implementing inlined constructs. Inhibits cross-module inlining but improves binary compatibility. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:880) + + + + + Don't add a resource to the generated assembly containing F#-specific metadata + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:881) + + + + + Name of the output file (Short form: -o) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:870) + + + + + Ignore ML compatibility warnings + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:900) + + + + + Link the specified resource to this assembly where the resinfo format is <file>[,<string name>[,public|private]] + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:888) + + + + + Specify a directory for the include path which is used to resolve source files and assemblies (Short form: -I) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:906) + + + + + Invalid warning level '%d' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:915) + + + + + The command-line option '%s' is for internal use only + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:929) + + + + + - RESOURCES - + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:921) + + + + + - OUTPUT FILES - + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:919) + + + + + - MISCELLANEOUS - + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:924) + + + + + - LANGUAGE - + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:925) + + + + + - INPUT FILES - + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:920) + + + + + - ERRORS AND WARNINGS - + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:926) + + + + + - CODE GENERATION - + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:922) + + + + + - ADVANCED - + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:923) + + + + + Display this usage message (Short form: -?) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:902) + + + + + Output messages with fully qualified paths + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:905) + + + + + Delay-sign the assembly using only the public portion of the strong name key + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:875) + + + + + Define conditional compilation symbols (Short form: -d) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:899) + + + + + Emit debug information (Short form: -g) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:889) + + + + + Specify debugging type: full, pdbonly. ('full' is the default and enables attaching a debugger to a running program). + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:890) + + + + + The command-line option '%s' has been deprecated + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:930) + + + + + The command-line option '%s' has been deprecated. HTML document generation is now part of the F# Power Pack, via the tool FsHtmlDoc.exe. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:932) + + + + + The command-line option '%s' has been deprecated. Use '%s' instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:931) + + + + + Enable or disable cross-module optimizations + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:893) + + + + + Copyright (c) Microsoft Corporation. All Rights Reserved. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:869) + + + + + Specify the codepage used to read source files + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:903) + + + + + Use to override where the compiler looks for mscorlib.dll and framework components + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:918) + + + + + The command-line option '--cliroot' has been deprecated. Use an explicit reference to a specific copy of mscorlib.dll instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:917) + + + + + Generate overflow checks + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:898) + + + + + Build a Windows executable + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:872) + + + + + Build a module that can be added to another assembly + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:874) + + + + + Build a library (Short form: -a) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:873) + + + + + Build a console executable + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:871) + + + + + Base address for the library to be built + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:907) + + + + + A value marked as 'inline' has an unexpected value + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1007) + + + + + A value marked as 'inline' could not be inlined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1008) + + + + + The value '%s' was marked inline but was not bound in the optimization environment + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1005) + + + + + The value '%s' was marked inline but its implementation makes use of an internal or private function which is not sufficiently accessible + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1004) + + + + + Recursive ValValue %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1010) + + + + + Local value %s not found during optimization + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1006) + + + + + Failed to inline the value '%s' marked 'inline', perhaps because a recursive value was marked 'inline' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1009) + + + + + Unexpected empty long identifier + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1025) + + + + + Multiple types exist called '%s', taking different numbers of generic parameters. Provide a type instantiation to disambiguate the type resolution, e.g. '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1021) + + + + + The instantiation of the generic type '%s' is missing and can't be inferred from the arguments or return type of this member. Consider providing a type instantiation when accessing this type, e.g. '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1022) + + + + + The type '%s' does not contain a field '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1026) + + + + + No constructors are available for the type '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1029) + + + + + This is not a constructor or literal, or a constructor is being used incorrectly + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1024) + + + + + Invalid module/expression/type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1020) + + + + + Invalid field label + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1027) + + + + + Invalid expression '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1028) + + + + + 'global' may only be used as the first name in a qualified path + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1023) + + + + + No Invoke methods found for delegate type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:975) + + + + + More than one Invoke method found for delegate type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:976) + + + + + Could not determine highest installed .NET framework version from Registry keys, using version 2.0 + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1124) + + + + + This construct is for ML compatibility. %s. You can disable this warning by using '--mlcompatibility' or '--nowarn:62'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1111) + + + + + Infix operator member '%s' has %d initial argument(s). Expected a tuple of 2 arguments, e.g. static member (+) (x,y) = ... + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1075) + + + + + Infix operator member '%s' has no arguments. Expected a tuple of 2 arguments, e.g. static member (+) (x,y) = ... + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1074) + + + + + Infix operator member '%s' has extra curried arguments. Expected a tuple of 2 arguments, e.g. static member (+) (x,y) = ... + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1076) + + + + + Identifiers containing '@' are reserved for use in F# code generation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:986) + + + + + The identifier '%s' is reserved for future use by F# + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:987) + + + + + Possible incorrect indentation: this token is offside of context started at position %s. Try indenting this token further or using standard formatting conventions. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1015) + + + + + The '|' tokens separating rules of this pattern match are misaligned by one column. Consider realigning your code or using further indentation. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1016) + + + + + The indentation of this 'in' token is incorrect with respect to the corresponding 'let' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1014) + + + + + Syntax error. Wrong nested #endif, unexpected tokens before it. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1072) + + + + + Unexpected character '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1041) + + + + + This token is reserved for future use + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1062) + + + + + This Unicode encoding is only valid in string literals + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1061) + + + + + TABs are not allowed in F# code unless the #indent \"off\" option is used + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1063) + + + + + This number is outside the allowable range for 32-bit unsigned integers + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1050) + + + + + This number is outside the allowable range for 32-bit signed integers + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1049) + + + + + This number is outside the allowable range for 64-bit unsigned integers + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1052) + + + + + This number is outside the allowable range for 64-bit signed integers + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1051) + + + + + This number is outside the allowable range for 16-bit unsigned integers + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1048) + + + + + This number is outside the allowable range for 16-bit signed integers + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1047) + + + + + This number is outside the allowable range for unsigned native integers + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1054) + + + + + This number is outside the allowable range for signed native integers + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1053) + + + + + This number is outside the allowable range for this integer type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1038) + + + + + This number is outside the allowable range for 8-bit unsigned integers + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1046) + + + + + This number is outside the allowable range for hexadecimal 8-bit signed integers + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1045) + + + + + This number is outside the allowable range for 8-bit signed integers + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1044) + + + + + This number is outside the allowable range for 32-bit floats + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1057) + + + + + This number is outside the allowable range for decimal literals + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1056) + + + + + Character sequences beginning with '?' are no longer permitted as operator names + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1040) + + + + + This is not a valid numeric literal. Sample formats include 4, 0x4, 0b0100, 4L, 4UL, 4u, 4s, 4us, 4y, 4uy, 4.0, 4.0f, 4I. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1058) + + + + + Invalid line number: '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1064) + + + + + Invalid floating point number + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1055) + + + + + This is not a valid character literal + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1060) + + + + + This is not a valid byte literal + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1059) + + + + + Consider using a file with extension '.ml' or '.mli' instead + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1118) + + + + + Identifiers followed by '%s' are reserved for future use + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1043) + + + + + #if directive should be immediately followed by an identifier + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1071) + + + + + #if directive must appear as the first non-whitespace character on a line + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1065) + + + + + #endif has no matching #if + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1069) + + + + + #endif required for #else + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1067) + + + + + #endif directive must appear as the first non-whitespace character on a line + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1070) + + + + + #else has no matching #if + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1066) + + + + + #else directive must appear as the first non-whitespace character on a line + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1068) + + + + + Expected single line comment or end of line + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1073) + + + + + '%s' is not permitted as a character in operator names and is reserved for future use + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1039) + + + + + This byte array literal contains characters that do not encode as a single byte + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1042) + + + + + The type '%s' is required here and is unavailable. You must add a reference to assembly '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:996) + + + + + A reference to the type '%s' in assembly '%s' was found, but the type could not be found in that assembly + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:997) + + + + + A reference to the DLL %s is required by assembly %s. The imported type %s is located in the first assembly and could not be resolved. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:999) + + + + + Internal error or badly formed metadata: not enough type parameters were in scope while importing + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:998) + + + + + An imported assembly uses the type '%s' but that type is not public + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1000) + + + + + PDB files cannot be generated when running on Mono + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1034) + + + + + Unexpected error creating debug information file '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1033) + + + + + Values marked with 'LiteralAttribute' must currently be simple integer, character, Boolean, string or floating point constants + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:849) + + + + + Values marked with 'LiteralAttribute' cannot be mutable + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:848) + + + + + Compiler error: unexpected unrealized value + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:857) + + + + + Unexpected GetSet annotation on a property + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:860) + + + + + Undefined value '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:842) + + + + + This type cannot be used for a literal field + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:859) + + + + + The StructLayout attribute could not be decoded + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:862) + + + + + GenSetStorage: %s was represented as a static method but was not an appropriate lambda expression + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:855) + + + + + The signature for this external function contains type parameters. Constrain the argument and return types to indicate the types of the corresponding C function. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:852) + + + + + Reflected definitions cannot contain uses of the prefix splice operator '%%' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:864) + + + + + Mutable variables cannot escape their method + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:856) + + + + + The MarshalAs attribute could not be decoded + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:851) + + + + + Main module of program is empty: nothing will happen when it is run + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:858) + + + + + Literal fields cannot be set + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:854) + + + + + Label %s not found + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:843) + + + + + Incorrect number of type arguments to local call + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:844) + + + + + The FieldOffset attribute could not be decoded + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:861) + + + + + The FieldOffset attribute can only be placed on members of types marked with the StructLayout(LayoutKind.Explicit) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1121) + + + + + The type '%s' has been marked as having an Explicit layout, but the field '%s' has not been marked with the 'FieldOffset' attribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1113) + + + + + Dynamic invocation of %s is not supported + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:845) + + + + + The DllImport attribute could not be decoded + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:853) + + + + + The DefaultAugmentation attribute could not be decoded + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:863) + + + + + Custom marshallers cannot be specified in F# code. Consider using a C# helper function. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:850) + + + + + This operation involves taking the address of a value '%s' represented using a local variable or other special representation. This is invalid. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:847) + + + + + Taking the address of a literal field is invalid + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:846) + + + + + This file was automatically generated by a call to Goto Definition + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:936) + + + + + If set to true, then all error messages will just return the filled 'holes' delimited by ',,,'s - this is for language-neutral testing (e.g. localization-invariant baselines). + + + + + Prefix flag (' ' or '+') set twice + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:237) + + + + + Precision missing after the '.' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:242) + + + + + Positional specifiers are not permitted in format strings + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:234) + + + + + Missing format specifier + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:235) + + + + + The 'l' or 'L' in this format specifier is unnecessary except for ML compatibility. In F# code you can use %%d, %%x, %%o or %%u instead, which are overloaded to work with all basic integer types. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:245) + + + + + The # formatting modifier is invalid in F# + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:238) + + + + + The 'h' or 'H' in this format specifier is unnecessary. You can use %%d, %%x, %%o or %%u instead, which are overloaded to work with all basic integer types.. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:246) + + + + + '%s' format does not support precision + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:243) + + + + + '%s' flag set twice + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:236) + + + + + '%s' format does not support '0' flag + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:241) + + + + + '%s' does not support prefix '%s' flag + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:247) + + + + + Bad width in format specifier + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:240) + + + + + Bad precision in format specifier + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:239) + + + + + Bad format specifier: '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:248) + + + + + Bad format specifier (after l or L): Expected ld,li,lo,lu,lx or lX. These format specifiers support ML compatibility. In F# code you can use %%d, %%x, %%o or %%u instead, which are overloaded to work with all basic integer types. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:244) + + + + + The record, struct or class field '%s' is not accessible from this code location + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:972) + + + + + This construct is experimental + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:974) + + + + + The event '%s' has a non-standard type. If this event is declared in another CLI language, you may need to access this event using the explicit %s and %s methods for the event. If this event is declared in F#, make the type of the event an instantiation of either 'IDelegateEvent<_>' or 'IEvent<_,_>'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:967) + + + + + System.Environment.Exit did not exit + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:252) + + + + + The treatment of this operator is now handled directly by the F# compiler and its meaning cannot be redefined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:253) + + + + + Delegates are not allowed to have curried signatures + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:977) + + + + + This type parameter cannot be instantiated to 'Nullable'. This is a restriction imposed in order to ensure the meaning of 'null' in some CLI languages is not confusing when used in conjunction with 'Nullable' values. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:349) + + + + + The type '%s' is not compatible with any of the types %s, arising from the use of a printf-style format string + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:352) + + + + + The type '%s' is not a CLI enum type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:346) + + + + + The type '%s' is not a CLI delegate type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:348) + + + + + Type instantiation length mismatch + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:356) + + + + + Type inference problem too complicated (maximum iteration depth reached). Consider adding further type annotations. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:330) + + + + + The type '%s' has a non-standard delegate type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:347) + + + + + The type '%s' does not support any operators named '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:334) + + + + + The type '%s' does not support the 'equality' constraint because it is a record, union or struct with one or more structural element types which do not support the 'equality' constraint. Either avoid the use of equality with this type, or add the 'StructuralEquality' attribute to the type to determine which field type does not support equality + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:345) + + + + + The type '%s' does not support the 'equality' constraint because it is a function type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:344) + + + + + The type '%s' does not support the 'equality' constraint because it has the 'NoEquality' attribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:343) + + + + + The type '%s' does not support a conversion to the type '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:335) + + + + + The type '%s' does not support the 'comparison' constraint because it is a record, union or struct with one or more structural element types which do not support the 'comparison' constraint. Either avoid the use of comparison with this type, or add the 'StructuralComparison' attribute to the type to determine which field type does not support comparison + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:342) + + + + + The type '%s' does not support the 'comparison' constraint. For example, it does not support the 'System.IComparable' interface + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:341) + + + + + The type '%s' does not support the 'comparison' constraint because it has the 'NoComparison' attribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:340) + + + + + The type '%s' does not have 'null' as a proper value + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:339) + + + + + The declared type parameter '%s' cannot be used here since the type parameter cannot be resolved at compile time + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:328) + + + + + The constraints 'struct' and 'not struct' are inconsistent + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:338) + + + + + The required signature is %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:368) + + + + + Optional arguments not permitted here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:357) + + + + + No overloads match for method '%s'. The available overloads are shown below (or in the Error List window). + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:383) + + + + + No %s member or object constructor named '%s' takes %d arguments. The named argument '%s' doesn't correspond to any argument or settable return property for any overload. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:381) + + + + + No %s member or object constructor named '%s' takes %d arguments. Note the call to this member also provides %d named arguments. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:380) + + + + + No %s member or object constructor named '%s' takes %d arguments + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:379) + + + + + Method or object constructor '%s' not found + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:382) + + + + + A unique overload for method '%s' could not be determined based on type information prior to this program point. The available overloads are shown below (or in the Error List window). A type annotation may be needed. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:384) + + + + + %s is not an instance method + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:366) + + + + + %s is not a static method + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:365) + + + + + The type '%s' has a method '%s' (full name '%s'), but the method is static + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:336) + + + + + The type '%s' has a method '%s' (full name '%s'), but the method is not static + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:337) + + + + + This method expects a CLI 'params' parameter in this position. 'params' is a way of passing a variable number of arguments to a method in languages such as C#. Consider passing an array for this argument + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:362) + + + + + The member or object constructor '%s' takes %d type argument(s) but is here given %d. The required signature is '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:375) + + + + + The member or object constructor '%s' requires %d argument(s) but is here given %d unnamed and %d named argument(s). The required signature is '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:373) + + + + + The member or object constructor '%s' takes %d argument(s) but is here given %d. The required signature is '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:374) + + + + + The member or object constructor '%s' requires %d additional argument(s). The required signature is '%s'. Some names for missing arguments are %s. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:372) + + + + + The member or object constructor '%s' requires %d argument(s). The required signature is '%s'. Some names for missing arguments are %s. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:371) + + + + + The member or object constructor '%s' requires %d additional argument(s). The required signature is '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:370) + + + + + The member or object constructor '%s' requires %d argument(s). The required signature is '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:369) + + + + + The member or object constructor '%s' does not take %d argument(s). An overload was found taking %d arguments. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:378) + + + + + The member or object constructor '%s' taking %d arguments are not accessible from this code location. All accessible versions of method '%s' take %d arguments. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:376) + + + + + %s is not a static member + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:358) + + + + + %s is not an instance member + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:359) + + + + + The member or object constructor '%s' is not %s. Private members may only be accessed from within the declaring type. Protected members may only be accessed from an extending type and cannot be accessed from inner lambda expressions. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:364) + + + + + The member or object constructor '%s' is not %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:363) + + + + + The member or object constructor '%s' has no argument or settable return property '%s'. %s. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:367) + + + + + This indexer expects %d arguments but is here given %d + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:332) + + + + + Incorrect generic instantiation. No %s member named '%s' takes %d generic arguments. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:377) + + + + + A generic construct requires that the type '%s' is an unmanaged type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:351) + + + + + A generic construct requires that the type '%s' is a CLI or F# struct type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:350) + + + + + A generic construct requires that the type '%s' have reference semantics, but it does not, i.e. it is a struct + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:353) + + + + + A generic construct requires that the type '%s' have a public default constructor + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:355) + + + + + A generic construct requires that the type '%s' be non-abstract + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:354) + + + + + Expected arguments to an instance member + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:331) + + + + + Expecting a type supporting the operator '%s' but given a function type. You may be missing an argument to a function. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:333) + + + + + This code is less generic than indicated by its annotations. A unit-of-measure specified using '_' has been determined to be '1', i.e. dimensionless. Consider making the code generic, or removing the use of '_'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:329) + + + + + The argument types don't match + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:361) + + + + + Argument length mismatch + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:360) + + + + + Quotations cannot contain expressions that set union case fields + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:315) + + + + + Quotations cannot contain expressions that set fields in exception values + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:316) + + + + + Quotations cannot contain expressions that require byref pointers + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:317) + + + + + Quotations cannot contain expressions that fetch union case indexes + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:314) + + + + + Quotations cannot contain this kind of type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:322) + + + + + Quotations cannot contain this kind of pattern match + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:320) + + + + + Quotations cannot contain this kind of constant + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:319) + + + + + Quotations cannot contain expressions that fetch static fields + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:311) + + + + + Quotations cannot contain object expressions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:309) + + + + + Quotations cannot contain literal byte arrays + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:323) + + + + + Quotations cannot contain inline assembly code or pattern matching on arrays + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:312) + + + + + Quotations cannot contain function declarations that are inferred or declared to be generic. Consider adding some type constraints to make this a valid quoted expression. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:308) + + + + + Quotations cannot contain uses of generic expressions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:307) + + + + + Quotations cannot contain descending for loops + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:313) + + + + + Quotations cannot contain array pattern matching + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:321) + + + + + Quotations cannot contain expressions that take the address of a field + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:310) + + + + + Quotations cannot contain expressions that make member constraint calls, or uses of operators that implicitly resolve to a member constraint call + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:318) + + + + + Inner generic functions are not permitted in quoted expressions. Consider adding some type constraints until this function is no longer generic. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:324) + + + + + The variable '%s' is bound in a quotation but is used as part of a spliced expression. This is not permitted since it may escape its scope. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:306) + + + + + The variable '%s' is used in an invalid way + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:261) + + + + + The type of a field using the 'DefaultValue' attribute must admit default initialization, i.e. have 'null' as a proper value or be a struct type whose fields all admit default initialization. You can use 'DefaultValue(false)' to disable this check + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:301) + + + + + The value '%s' is unused + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1087) + + + + + The recursive object reference '%s' is unused. The presence of a recursive object reference adds runtime initialization checks to members in this and derived types. Consider removing this recursive object reference. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1088) + + + + + default augmentation of the union case + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:286) + + + + + compiled form of the union case + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:285) + + + + + The type '%s' is less accessible than the value, member or type '%s' it is used in + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:262) + + + + + 'System.Void' can only be used as 'typeof<System.Void>' in F# + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:263) + + + + + Expression-splicing operators may only be used within quotations + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:266) + + + + + A method return type would contain byrefs which is not permitted + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:278) + + + + + [<ReflectedDefinition>] terms cannot contain uses of the prefix splice operator '%%' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:283) + + + + + A protected member is called or 'base' is being used. This is only allowed in the direct implementation of members since they could escape their object scope. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:257) + + + + + Name clash. The property '%s' has the same name as a method in this type. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:287) + + + + + The property '%s' has the same name as another property in this type, but one takes indexer arguments and the other does not. You may be missing an indexer argument to one of your properties. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:289) + + + + + Object constructors cannot directly use try/with and try/finally prior to the initialization of the object. This includes constructs such as 'for x in ...' that may elaborate to uses of these constructs. This is a limitation imposed by Common IL. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:272) + + + + + First-class uses of the expression-splicing operator are not permitted + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:267) + + + + + First-class uses of the 'reraise' function is not permitted + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:269) + + + + + First-class uses of the address-of operators are not permitted + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:268) + + + + + The type abbreviation contains byrefs. This is not permitted by F#. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:302) + + + + + The byref typed value '%s' cannot be used at this point + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:270) + + + + + A byref typed value would be stored here. Top-level let-bound byref values are not permitted. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:282) + + + + + The address of the static field '%s' cannot be used at this point + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:274) + + + + + The address of the variable '%s' cannot be used at this point + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:273) + + + + + The address of an array element cannot be used at this point + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:276) + + + + + The address of the field '%s' cannot be used at this point + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:275) + + + + + The mutable variable '%s' is used in an invalid way. Mutable variables cannot be captured by closures. Consider eliminating this use of mutation or using a heap-allocated mutable reference cell via 'ref' and '!'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:259) + + + + + This type implements or inherits the same interface at different generic instantiations '%s' and '%s'. This is not permitted in this version of F#. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:300) + + + + + The member '%s' is used in an invalid way. A use of '%s' has been inferred prior to its definition at or near '%s'. This is an invalid forward reference. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:281) + + + + + 'base' values may only be used to make direct calls to the base implementations of overridden members + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:271) + + + + + Invalid custom attribute value (not a constant or literal) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:279) + + + + + The property '%s' has a getter and a setter that do not match. If one is abstract then the other must be as well. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:288) + + + + + The type of a first-class function cannot contain byrefs + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:277) + + + + + A type instantiation involves a byref type. This is not permitted by the rules of Common IL. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:264) + + + + + Calls to 'reraise' may only occur directly in a handler of a try-with + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:265) + + + + + A function labeled with the 'EntryPointAttribute' attribute must be the last declaration in the last file in the compilation sequence, and can only be used when compiling to a .exe + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:284) + + + + + Duplicate property. The property '%s' has the same name and signature as another property in this type once tuples, functions and/or units of measure are erased. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:297) + + + + + Duplicate property. The property '%s' has the same name and signature as another property in this type. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:296) + + + + + Duplicate method. The method '%s' has the same name and signature as another method in this type once tuples, functions and/or units of measure are erased. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:293) + + + + + Duplicate method. The abstract method '%s' has the same name and signature as an abstract method in an inherited type once tuples, functions and/or units of measure are erased. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:299) + + + + + Duplicate method. The abstract method '%s' has the same name and signature as an abstract method in an inherited type. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:298) + + + + + The method '%s' has curried arguments but has the same name as another method in this type. Methods with curried arguments cannot be overloaded. Consider using a method taking tupled arguments. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:294) + + + + + Duplicate method. The method '%s' has the same name and signature as another method in this type. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:292) + + + + + Methods with curried arguments cannot declare 'out', 'ParamArray', 'optional' or 'byref' arguments + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:295) + + + + + A type would store a byref typed value. This is not permitted by Common IL. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:290) + + + + + The byref-typed variable '%s' is used in an invalid way. Byrefs cannot be captured by closures or passed to inner functions. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:258) + + + + + The 'base' keyword is used in an invalid way. Base calls cannot be used in closures. Consider using a private member to make base calls. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:260) + + + + + The attribute type '%s' has 'AllowMultiple=false'. Multiple instances of this attribute cannot be attached to a single language element. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:280) + + + + + Unrecognized option: '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:60) + + + + + ParseInput: unknown file suffix for '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:41) + + + + + The non-generic type '%s' does not expect any type arguments, but here is given %d type argument(s) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:17) + + + + + The signature file '%s' does not have a corresponding implementation file. If an implementation file exists then check the 'module' and 'namespace' declarations in the signature and implementation files match. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:57) + + + + + A signature for the file or module '%s' has already been specified + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:54) + + + + + The search directory '%s' could not be found + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:27) + + + + + The file '%s' is a CLI 1.x version of mscorlib. F# requires CLI version 2.0 or greater. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:32) + + + + + Microsoft (R) F# 2.0 Compiler build %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:21) + + + + + Problem with filename '%s': %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:22) + + + + + The '--pdb' option requires the '--debug' option to be used + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:25) + + + + + Option requires parameter: %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:42) + + + + + No inputs specified + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:23) + + + + + This file contains multiple declarations of the form 'module SomeNamespace.SomeModule'. Only one declaration of this form is permitted in a file. Change your file to use an initial namespace declaration and/or use 'module ModuleName = ...' to define your modules. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:40) + + + + + Multiple references to '%s.dll' are not permitted + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:31) + + + + + Files in libraries or multiple-file applications must begin with a namespace or module declaration, e.g. 'namespace SomeNamespace.SubNamespace' or 'module SomeNamespace.SomeModule' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:39) + + + + + The referenced or default base CLI library 'mscorlib' is binary-incompatible with the referenced library '%s'. Consider recompiling the library or making an explicit reference to a version of this library that matches the CLI version you are using. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:34) + + + + + The referenced or default base CLI library 'mscorlib' is binary-incompatible with the referenced F# core library '%s'. Consider recompiling the library or making an explicit reference to a version of this library that matches the CLI version you are using. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:36) + + + + + The output name extension doesn't match the options used. If '-a' or '--target:library' is used the output file name must end with '.dll', if '--target:module' is used the output extension must be '.netmodule', otherwise '.exe'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:24) + + + + + Invalid warning number '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:18) + + + + + Invalid version string '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:19) + + + + + Invalid version file '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:20) + + + + + The file extension of '%s' is not recognized. Source files must have extension .fs, .fsi, .fsx, .fsscript, .ml or .mli. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:44) + + + + + The search directory '%s' is invalid + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:26) + + + + + Unrecognized privacy setting '%s' for managed resource, valid options are 'public' and 'private' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:30) + + + + + Invalid module or namespace name + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:61) + + + + + Invalid directive. Expected '#time', '#time \"on\"' or '#time \"off\"'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:52) + + + + + Invalid directive. Expected '#r \"<file-or-assembly>\"'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:50) + + + + + Invalid directive. Expected '#load \"<file>\" ... \"<file>\"'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:51) + + + + + Invalid directive. Expected '#I \"<path>\"'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:49) + + + + + '%s' is not a valid filename + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:28) + + + + + '%s' is not a valid assembly name + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:29) + + + + + The declarations in this file will be placed in an implicit module '%s' based on the file name '%s'. However this is not a valid F# identifier, so the contents will not be accessible from other files. Consider renaming the file or adding a 'module' or 'namespace' declaration at the top of the file. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:38) + + + + + An implementation of file or module '%s' has already been given. Compilation order is significant in F# because of type inference. You may need to adjust the order of your files to place the signature file before the implementation. In Visual Studio files are type-checked in the order they appear in the project file, which can be edited manually or adjusted using the solution explorer. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:55) + + + + + An implementation of the file or module '%s' has already been given + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:56) + + + + + When mscorlib.dll or FSharp.Core.dll is explicitly referenced the %s option must also be passed + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:62) + + + + + FSharp.Core.sigdata not found alongside FSharp.Core + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:64) + + + + + File '%s' not found alongside FSharp.Core + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:66) + + + + + Error opening binary file '%s': %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:47) + + + + + Directives inside modules are ignored + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:53) + + + + + The F#-compiled DLL '%s' needs to be recompiled to be used with this version of F# + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:48) + + + + + Did not expect to find sigdata resource in FSharp.Core.dll + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:63) + + + + + Did not expect to find optdata resource in FSharp.Core.dll + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:65) + + + + + Could not resolve assembly '%s' required by '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:46) + + + + + Could not resolve assembly '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:45) + + + + + Could not read version from mscorlib.dll + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:33) + + + + + Source file '%s' could not be found + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:43) + + + + + The file extensions '.ml' and '.mli' are for ML compatibility + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1117) + + + + + Unable to read assembly '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:35) + + + + + Assembly resolution failure at or near this location + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:37) + + + + + '%s' is not a valid integer argument + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:58) + + + + + '%s' is not a valid floating point argument + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:59) + + + + + A type cannot have both the 'ReferenceEquality' and 'StructuralEquality' or 'StructuralComparison' attributes + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:223) + + + + + The 'StructuralEquality' attribute must be used in conjunction with the 'NoComparison' or 'StructuralComparison' attributes + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:222) + + + + + The 'StructuralComparison' attribute must be used in conjunction with the 'StructuralEquality' attribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:221) + + + + + A type with attribute 'ReferenceEquality' cannot have an explicit implementation of 'Object.Equals(obj)', 'System.IEquatable<_>' or 'System.Collections.IStructuralEquatable' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:225) + + + + + Only record, union, exception and struct types may be augmented with the 'ReferenceEquality', 'StructuralEquality' and 'StructuralComparison' attributes + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:224) + + + + + The 'ReferenceEquality' attribute cannot be used on structs. Consider using the 'StructuralEquality' attribute instead, or implement an override for 'System.Object.Equals(obj)'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:218) + + + + + The 'NoEquality' attribute must be used in conjunction with the 'NoComparison' attribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:220) + + + + + A type with attribute 'NoEquality' should not usually have an explicit implementation of 'Object.Equals(obj)'. Disable this warning if this is intentional for interoperability purposes + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:228) + + + + + A type with attribute 'NoComparison' should not usually have an explicit implementation of 'System.IComparable', 'System.IComparable<_>' or 'System.Collections.IStructuralComparable'. Disable this warning if this is intentional for interoperability purposes + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:229) + + + + + This type uses an invalid mix of the attributes 'NoEquality', 'ReferenceEquality', 'StructuralEquality', 'NoComparison' and 'StructuralComparison' attributes + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:219) + + + + + A type with attribute 'CustomEquality' must have an explicit implementation of at least one of 'Object.Equals(obj)', 'System.IEquatable<_>' or 'System.Collections.IStructuralEquatable' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:226) + + + + + The 'CustomEquality' attribute must be used in conjunction with the 'NoComparison' or 'CustomComparison' attributes + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:230) + + + + + A type with attribute 'CustomComparison' must have an explicit implementation of at least one of 'System.IComparable' or 'System.Collections.IStructuralComparable' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:227) + + + + + Error while parsing embedded IL type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:212) + + + + + Error while parsing embedded IL + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:211) + + + + + Invalid expression on left of assignment + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:214) + + + + + This indexer notation has been removed from the F# language + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:213) + + + + + .NET Framework + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:960) + + + + + Global Assembly Cache + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:961) + + + + + Found by AssemblyFolders registry key + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:958) + + + + + Found by AssemblyFoldersEx registry key + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:959) + + + + + Active pattern '%s' is not a function + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1119) + + + + + Active pattern '%s' has a result type containing type variables that are not determined by the input. The common cause is a when a result case is not mentioned, e.g. 'let (|A|B|) (x:int) = A x'. This can be fixed with a type constraint, e.g. 'let (|A|B|) (x:int) : Choice<int,unit> = A x' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1120) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nOne is virtual and the other isn't + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:120) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe types differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:112) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nOne is static and the other isn't + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:119) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe compiled representation of this method is as a static member but the signature indicates its compiled representation is as an instance member + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:125) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe respective type parameter counts differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:111) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nOne is marked as an override and the other isn't + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:123) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nOne is a type function and the other is not. The signature requires explicit type parameters if they are present in the implementation. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:110) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nOne is a constructor/property and the other is not + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:124) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe names differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:104) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe literal constant values and/or attributes differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:109) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe compiled representation of this method is as an instance member, but the signature indicates its compiled representation is as a static member + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:126) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe inline flags differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:108) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe number of generic parameters in the signature and implementation differ (the signature declares %s but the implementation declares %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:115) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe generic parameters in the signature and implementation have different kinds. Perhaps there is a missing [<Measure>] attribute. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:116) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nOne is final and the other isn't + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:122) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nOne is an extension member and the other is not + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:113) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe CLI member names differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:118) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe display names differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:106) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe compiled names differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:105) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe mutability attributes differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:103) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nAn arity was not inferred for this value + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:114) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe arities in the signature and implementation differ. The signature specifies that '%s' is function definition or lambda expression accepting at least %s argument(s), but the implementation is a computed function value. To declare that a computed function value is a permitted implementation simply parenthesize its type in the signature, e.g.\n\tval %s: int -> (int -> int)\ninstead of\n\tval %s: int -> int -> int. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:117) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe accessibility specified in the signature is more than that specified in the implementation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:107) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nOne is abstract and the other isn't + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:121) + + + + + Call this method once to validate that all known resources are valid; throws if not + + + + + The module contains the constructor\n %s \nbut its signature specifies\n %s \nThe types of the fields differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:161) + + + + + The module contains the constructor\n %s \nbut its signature specifies\n %s \nThe names differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:159) + + + + + The module contains the constructor\n %s \nbut its signature specifies\n %s \nThe respective number of data fields differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:160) + + + + + The module contains the constructor\n %s \nbut its signature specifies\n %s \nthe accessibility specified in the signature is more than that specified in the implementation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:162) + + + + + Invalid recursive reference to an abstract slot + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:966) + + + + + The module contains the field\n %s \nbut its signature specifies\n %s \nThe types differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:168) + + + + + The module contains the field\n %s \nbut its signature specifies\n %s \nThe 'static' modifiers differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:165) + + + + + The module contains the field\n %s \nbut its signature specifies\n %s \nThe names differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:163) + + + + + The module contains the field\n %s \nbut its signature specifies\n %s \nThe 'mutable' modifiers differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:166) + + + + + The module contains the field\n %s \nbut its signature specifies\n %s \nThe 'literal' modifiers differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:167) + + + + + The module contains the field\n %s \nbut its signature specifies\n %s \nthe accessibility specified in the signature is more than that specified in the implementation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:164) + + + + + The exception definitions are not compatible because the exception abbreviations in the signature and implementation differ. The module contains the exception definition\n %s \nbut its signature specifies\n\t%s. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:187) + + + + + The exception definitions are not compatible because a CLI exception mapping is being hidden by a signature. The exception mapping must be visible to other modules. The module contains the exception definition\n %s \nbut its signature specifies\n\t%s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:184) + + + + + The exception definitions are not compatible because the order of the fields is different in the signature and implementation. The module contains the exception definition\n %s \nbut its signature specifies\n\t%s. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:191) + + + + + The exception definitions are not compatible because the field '%s' was required by the signature but was not specified by the implementation. The module contains the exception definition\n %s \nbut its signature specifies\n\t%s. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:189) + + + + + The exception definitions are not compatible because the field '%s' was present in the implementation but not in the signature. The module contains the exception definition\n %s \nbut its signature specifies\n\t%s. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:190) + + + + + The exception definitions are not compatible because the exception declarations differ. The module contains the exception definition\n %s \nbut its signature specifies\n\t%s. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:188) + + + + + The exception definitions are not compatible because the CLI representations differ. The module contains the exception definition\n %s \nbut its signature specifies\n\t%s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:185) + + + + + The exception definitions are not compatible because the exception abbreviation is being hidden by the signature. The abbreviation must be visible to other CLI languages. Consider making the abbreviation visible in the signature. The module contains the exception definition\n %s \nbut its signature specifies\n\t%s. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:186) + + + + + The %s definitions in the signature and implementation are not compatible because the types have different base types + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:139) + + + + + The %s definitions in the signature and implementation are not compatible because a type representation is being hidden by a signature + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:145) + + + + + The %s definitions in the signature and implementation are not compatible because the types are of different kinds + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:146) + + + + + The %s definitions in the signature and implementation are not compatible because the signature says this type may use nulls as an extra value but the implementation does not + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:134) + + + + + The %s definitions in the signature and implementation are not compatible because the signature says this type may use nulls as a representation but the implementation does not + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:133) + + + + + The %s definitions in the signature and implementation are not compatible because the signature is an abstract class but the implementation is not. Consider adding the [<AbstractClass>] attribute to the implementation. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:138) + + + + + The %s definitions in the signature and implementation are not compatible because the signature defines the %s '%s' but the implementation does not (or does, but not in the same order) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:141) + + + + + The %s definitions in the signature and implementation are not compatible because the signature declares a %s while the implementation declares a %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:155) + + + + + The %s definitions in the signature and implementation are not compatible because the signature has an abbreviation while the implementation does not + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:158) + + + + + The %s definitions in the signature and implementation are not compatible because the representations differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:148) + + + + + The %s definitions in the signature and implementation are not compatible because the respective type parameter counts differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:128) + + + + + The %s definitions in the signature and implementation are not compatible because the number of %ss differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:140) + + + + + The %s definitions in the signature and implementation are not compatible because the names differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:127) + + + + + The %s definitions in the signature and implementation are not compatible because the signature requires that the type supports the interface %s but the interface has not been implemented + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:130) + + + + + The %s definitions in the signature and implementation are not compatible because the implementation type is sealed but the signature implies it is not. Consider adding the [<Sealed>] attribute to the signature. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:135) + + + + + The %s definitions in the signature and implementation are not compatible because the implementation says this type may use nulls as an extra value but the signature does not + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:132) + + + + + The %s definitions in the signature and implementation are not compatible because the implementation says this type may use nulls as a representation but the signature does not + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:131) + + + + + The %s definitions in the signature and implementation are not compatible because the implementation type is not sealed but signature implies it is. Consider adding the [<Sealed>] attribute to the implementation. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:136) + + + + + The %s definitions in the signature and implementation are not compatible because the implementation is an abstract class but the signature is not. Consider adding the [<AbstractClass>] attribute to the signature. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:137) + + + + + The %s definitions in the signature and implementation are not compatible because the implementation defines a struct but the signature defines a type with a hidden representation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:143) + + + + + The %s definitions in the signature and implementation are not compatible because the implementation defines the %s '%s' but the signature does not (or does, but not in the same order) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:142) + + + + + The %s definitions in the signature and implementation are not compatible because the IL representations differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:147) + + + + + The %s definitions in the signature and implementation are not compatible because the field %s was present in the implementation but not in the signature + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:149) + + + + + The %s definitions in the signature and implementation are not compatible because the field %s was required by the signature but was not specified by the implementation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:151) + + + + + The %s definitions in the signature and implementation are not compatible because the order of the fields is different in the signature and implementation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:150) + + + + + The %s definitions in the signature and implementation are not compatible because the field %s was present in the implementation but not in the signature. Struct types must now reveal their fields in the signature for the type, though the fields may still be labelled 'private' or 'internal'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:152) + + + + + The %s definitions in the signature and implementation are not compatible because a CLI type representation is being hidden by a signature + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:144) + + + + + The %s definitions in the signature and implementation are not compatible because the accessibility specified in the signature is more than that specified in the implementation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:129) + + + + + The %s definitions in the signature and implementation are not compatible because the abstract member '%s' was present in the implementation but not in the signature + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:154) + + + + + The %s definitions in the signature and implementation are not compatible because the abstract member '%s' was required by the signature but was not specified by the implementation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:153) + + + + + The %s definitions in the signature and implementation are not compatible because the abbreviations differ: %s versus %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:156) + + + + + The %s definitions in the signature and implementation are not compatible because an abbreviation is being hidden by a signature. The abbreviation must be visible to other CLI languages. Consider making the abbreviation visible in the signature. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:157) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Convert string into Option string where null and String.Empty result in None + + + + + + + + + + + + + + Get the System.Reflection.Assembly object for the assembly + + + + + Holds the full qualified assembly name + + + + + Get the object representing the F# core library (FSharp.Core.dll) for the running program + + + + + A handle to the full specification of the contents of the module contained in this Assembly + + + + + A hint as to where does the code for the CCU live (e.g what was the tcConfig.implicitIncludeDir at compilation time for this DLL?) + + + + + Return the System.Reflection.Assembly object for the assembly + + + + + This is one way of starting the loading process off. + + + + + This is one way of starting the loading process off. Dependencies are automatically + resolved by calling System.Reflection.Assembly.Load. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Get the XML documentation signature for the entity + + + + + Indicates the type prefers the "tycon<a,b>" syntax for display etc. + + + + + Get the cases of a discriminated union + + + + + Get the declared accessibility of the representation, not taking signatures into account + + + + + Get the System.Type for the type + + Raises InvalidOperationException if the type is an abbreviation or has an assembly code representation. + + + + + Get the System.Reflection.Assembly for the type + + May raise an exception if an assembly load fails + + + + + Get the fields of the class, struct or enum + + + + + Get the fully qualified name of the type or module + + + + + + + + Get the namespace containing the type or module, if any + + + + + Properties, methods etc. with implementations, also values in a module + + + + + Get the name of the type or module, possibly with `n mangling + + + + + Indicates the entity is a struct or enum + + + + + Indicates the entity is union type + + + + + Indicates the entity is record type + + + + + Indicates the entity is an F# module definition + + + + + Indicates the entity is a measure definition + + + + + If true, then this is a reference to something in some .NET assembly from another .NET language + + + + + Indicates an F# exception declaration + + + + + Indicates the entity is a measure, type or exception abbreviation + + + + + Interface implementations - boolean indicates compiler-generated + + + + + Indicates that a module is compiled to a class with the given mangled name. The mangling is reversed during lookup + + + + + Indicates the type is implemented through a mapping to IL assembly code. THis is only + true for types in FSharp.Core.dll + + + + + Get the generic parameters, possibly including unit-of-measure parameters + + + + + Get the name of the type or module as displayed in F# code + + + + + Get the entity containing the type or module, if any + + + + + Get the declaration location for the type constructor + + + + + Get the compiled name of the type or module, possibly with `n mangling. This is identical to LogicalName + unless the CompiledName attribute is used. + + + + + Base type, if any + + + + + Get the declared attributes for the type + + + + + Get the declared accessibility of the type + + + + + + + + Return the FSharpEntity corresponding to a .NET type + + + + + Represents an F# type or module + + + + + + + + + + + Get the documentation for the type parameter. + + + + + Get the name of the generic parameter + + + + + Indicates if this is a statically resolved type variable + + + + + Indicates if this is a measure variable + + + + + Get the range of the generic parameter + + + + + Get the declared or inferred constraints for the type parameter + + + + + Get the declared attributes of the type parameter. + + + + + + + + + + + + + + + + + + + + + + + + + + Indicates a constraint that a type is an unmanaged type + + + + + Indicates a constraint that a type has a 'null' value + + + + + Indicates a constraint that a type is a simple choice between one of the given ground types. Used by printf format strings. + + + + + Indicates a constraint that a type has a parameterless constructor + + + + + Indicates a constraint that a type is a reference type + + + + + Indicates a constraint that a type is a non-Nullable value type + + + + + Indicates a constraint that a type has a member with the given signature + + + + + Indicates a constraint that a type supports F# generic equality + + + + + Indicates a constraint that a type is an enum with the given underlying + + + + + Indicates a constraint that a type is a delegate from the given tuple of args to the given return type + + + + + Indicates a default value for an inference type variable should it be netiher generalized nor solved + + + + + Indicates a constraint that a type supports F# generic comparison + + + + + Indicates a constraint that a type is a subtype of the given type + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Indictes the value is inlined but the code for the function still exists, e.g. to satisfy interfaces on objects, but that it is also always inlined + + + + + + + + + + + + + + + + + + + + XML documentation signature for the value. + + + + + Get the full type of the member or value when used as a first class value + + + + + + + + Get the reflection object for this member + + + + + Get the logical name of the member + + + + + Get the logical enclosing entity, which for an extension member is type being extended + + + + + Indicates if this is an F# type function + + + + + Indicates if this is a setter method for a property + + + + + Indicates if this is a mutable value + + + + + Indicates if this is a module or member value + + + + + Indicates if this is a member, including extension members? + + + + + Indicates if this is an instance member, when seen from F#? + + + + + Indicates if this is an implicit constructor? + + + + + Indicates if this is a getter method for a property + + + + + Indicates if this is an extension member? + + + + + Indicates if this is an abstract member? + + + + + Indicates if this is a compiler generated value + + + + + Indicates if this value or member is an F# active pattern + + + + + Get a result indicating if this is a must-inline value + + + + + Get the typars of the member or value + + + + + + + + Get the name as presented in F# error messages and documentation + + + + + Get the declaration location of the member or value + + + + + + + + Get the member name in compiled code + + + + + Custom attributes attached to the value. These contain references to other values (i.e. constructors in types). Mutable to fixup + these value references after copying a colelction of values. + + + + + How visible is this? + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Get the XML documentation signature for the field + + + + + Get the type of the field, w.r.t. the generic parameters of the enclosing type constructor + + + + + Get the attributes attached to generated property + + + + + Get the name of the field + + + + + Indicates a static field + + + + + Is the field declared in F#? + + + + + Indicates a compiler generated field, not visible to Intellisense or name resolution + + + + + Get the attributes attached to generated field + + + + + Get the declaration location of the field + + + + + Indicates the declared visibility of the field, not taking signatures into account + + + + + + + + + + + + + + Get the named entity for a type constructed using a named entity + + + + + Indicates the type is a tuple type. The GenericArguments property returns the elements of the tuple type. + + + + + Indicates the type is constructed using a named entity + + + + + Indicates the type is a variable type, whether declared, generalized or an inference type parameter + + + + + Indicates the type is a function type. The GenericArguments property returns the domain and range of the function type. + + + + + Get the index for a generic parameter type + + + + + Get the generic parameter data for a generic parameter type + + + + + Get the generic arguments for a tuple type, a function type or a type constructed using a named entity + + + + + + + + + + + + + + Get the XML documentation signature for the case + + + + + Get type constructed by the case. Normally exactly the type of the enclosing type, sometimes an abbreviation of it + + + + + Get the name of the case + + + + + Get the data carried by the case. + + + + + Get the range of the name of the case + + + + + Gete the name of the case in generated IL code + + + + + Get the attributes for the case, attached to the generated static method to make instances of the case + + + + + Indicates the declared visibility of the union constructor, not taking signatures into account + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Note this operation is O(n) anyway, so executing lastElements() here is OK + + + + + Note this operation is O(1), unless a push happens, which is rare + + + + + + + + + + + + + + + + + Iterable functional collection with O(1) append-1 time. Useful for data structures where elements get added at the + end but the collection must occadionally be iterated. Iteration is slower and may allocate because + a suffix of elements is stored in reverse order. + + The type doesn't support structural hashing or comparison. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + keyed first on namespace then on type name. The namespace is often a unique key for a given type map. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + The explicit offset in bytes when explicit layout is used. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Index table by name and arity. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + The type instantiation if the type is generic + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Calling conventions. These are used in method pointer types. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Global state: table of all assembly references keyed by AssemblyRefData + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + This is used to store event, property and field maps. + + Review: this is not such a great data structure. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Global State. All namespace splits + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + A little ugly, but the idea is that if a data structure does not + contain lazy values then we don't add laziness. So if the thing to map + is already evaluated then immediately apply the function. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + The assumptions that need to be fixed up + + + + + The data that uses a collection of CcuThunks internally + + + + + Like Fixup but loader may return None, in which case there is no fixup. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + This field holds either the function to run or a PPLazyFailure object recording the exception raised + from running the function. It is null if the thunk has been evaluated successfully. + + + + + This field holds the result of a successful computation. It's initial value is Unchecked.defaultof + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Treat a list of key-value pairs as a lookup collection. + This function returns true if two keys are the same according to the predicate + function passed in. + + + + + Treat a list of key-value pairs as a lookup collection. + This function looks up a value based on a match from the supplied + predicate function. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Try to chop "get_" or "set_" from a string + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Specifies the compiled representations of type and exception definitions. + Computed and cached by later phases (never computed type checking). Cached at + type and exception definitions. Not pickled. Cache an optional ILType object for + non-generic types + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + A representation of a method in an object expression. + Note: Methods associated with types are represented as val declarations + Note: We should probably use val_specs for object expressions, as then the treatment of members + in object expressions could be more unified with the treatment of members in types + + + + + + + + + + + + + + A call to a base method, e.g. 'base.OnPaint(args)' + + + + + A call to a constructor, e.g. 'new C() = new C(3)' + + + + + A call to a constructor, e.g. 'inherit C()' + + + + + A normal use of a value + + + + + Indicates a use of a value represents a call to a method that may require + a .NET 2.0 constrained call. A constrained call is only used for calls where + + + + + + + + let res = a in b;res + + + + + a ; b + + + + + + + + In C syntax this is: *localv_ptr = e + + + + + In C syntax this is: localv = e , note == *(&localv) = e == LGetAddr; LByrefSet + + + + + In C syntax this is: *localv_ptr + + + + + In C syntax this is: &localv + + + + + + + + Evaluate start once and end multiple times, loop up + + + + + Evaluate start and end once, loop down + + + + + Evaluate start and end once, loop up + + + + + + + + + + + + + + + + + + + + IL method calls + + + + + Operation nodes represnting C-style operations on byrefs and mutable vals (l-values) + + + + + Pseudo method calls. This is used for overloaded operations like op_Addition. + + + + + + + + Represents a "rethrow" operation. May not be rebound, or used outside of try-finally, expecting a unit argument + + + + + Conversion node, compiled via type-directed translation or to box/unbox + + + + + generate a ldflda on an 'a ref. + + + + + IL assembly code - type list are the types pushed on the stack + + + + + An operation representing a field-get from an F# tuple value. + + + + + An operation representing a field-set on an F# exception value. + + + + + An operation representing a field-get from an F# exception value. + + + + + An operation representing a field-get from a union value. THe value is not assumed to have been proven to be of the corresponding union case. + + + + + An operation representing a field-get from a union value, where that value has been proven to be of the corresponding union case. + + + + + An operation representing a coercion that proves a union value is of a particular union case. THis is not a test, its + simply added proof to enable us to generate verifiable code for field access on union types + + + + + An operation representing getting an integer tag for a union value representing the union case number + + + + + An operation representing getting the address of a record field + + + + + An operation representing getting a record field + + + + + An operation representing setting a record field + + + + + Construct a record or object-model value. The ValRef is for self-referential class constructors, otherwise + it indicates that we're in a constructor and the purpose of the expression is to + fill in the fields of a pre-created but uninitialized object, and to assign the initialized + version of the object into the optional mutable cell pointed to be the given value. + + + + + An operation representing a lambda-encoded try/finally + + + + + An operation representing a lambda-encoded try/catch + + + + + An operation representing a lambda-encoded for loop + + + + + An operation representing a lambda-encoded while loop. The special while loop marker is used to mark compilations of 'foreach' expressions + + + + + + + + Constant bytes, but a new mutable blob is generated each time the construct is executed + + + + + An operation representing the creation of an array value + + + + + An operation representing the creation of a tuple value + + + + + An operation representing the creation of an exception value using an F# exception declaration + + + + + An operation representing the creation of a union value of the particular union case + + + + + + + + Normal record construction + + + + + We're in a constructor. The purpose of the record expression is to + fill in the fields of a pre-created but uninitialized object + + + + + This ModuleOrNamespace that represents the compilation of a module as a class. + The same set of tycons etc. are bound in the ModuleOrNamespace as in the ModuleOrNamespaceExpr + This is the body of the module/namespace + + + + + + + + A named module-or-namespace-fragment definition + + + + + Indicates the module fragment is a 'rec' definition of types, values and modules + + + + + Indicates the module fragment is an evaluation of expression for side-effects + + + + + Indicates the module fragment is a 'let' definition + + + + + Indicates the module fragment is made of several module fragments in succession + + + + + Indicates the module is a module with a signature + + + + + The module_typ is a binder. However it is not used in the ModuleOrNamespaceExpr: it is only referenced from the 'outside' + The contents of a module-or-namespace-fragment definition + + + + + + + + A type for a module-or-namespace-fragment and the actual definition of the module-or-namespace-fragment + + + + + Typechecking residue: A TExpr_link occurs for every use of a recursively bound variable. While type-checking + the recursive bindings a dummy expression is stored in the mutable reference cell. + After type checking the bindings this is replaced by a use of the variable, perhaps at an + appropriate type instantiation. These are immediately eliminated on subsequent rewrites. + + + + + Typechecking residue: Indicates a free choice of typars that arises due to + minimization of polymorphism at let-rec bindings. These are + resolved to a concrete instantiation on subsequent rewrites. + + + + + + + + An intrinsic applied to some (strictly evaluated) arguments + A few of intrinsics (TOp_try, TOp_while, TOp_for) expect arguments kept in a normal form involving lambdas + + + + + If we statically know some infomation then in many cases we can use a more optimized expression + This is primarily used by terms in the standard library, particularly those implementing overloaded + operators. + + + + + Matches are a more complicated form of "let" with multiple possible destinations + and possibly multiple ways to get to each destination. + The first mark is that of the expression being matched, which is used + as the mark for all the decision making and binding that happens during the match. + + + + + + + + Bind a value. + + + + + Bind a recursive set of values. + + + + + Applications combine type and term applications, and are normalized so + that sequential applications are combined, so "(f x y)" becomes "f [[x];[y]]". + The type attached to the function is the formal function type, used to ensure we don't build application + nodes that over-apply when instantiating at function types. + + + + + + + + Lambda expressions. + + + + + Sequence expressions, used for "a;b", "let a = e in b;a" and "a then b" (the last an OO constructor). + + + + + Reference a value. The flag is only relevant if the value is an object model member + and indicates base calls and special uses of object constructors. + + + + + A constant expression. + + + + + The big type of expressions. + + + + + + + + + + + + + + + + + + + + + + + The extra metadata stored about typars for top-level definitions. Any information here is propagated from signature through + to the compiled code. + + + + + + + + + + + The extra metadata stored about typars for top-level definitions. Any information here is propagated from signature through + to the compiled code. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + A target of a decision tree. Can be thought of as a little function, though is compiled as a local block. + + + + + Run the active pattern and bind a successful result to the (one) variable in the remaining tree + + + + + Test if the input to a decision tree is an instance of the given type + + + + + Test if the input to a decision tree is null + + + + + Test if the input to a decision tree is the given constant value + + + + + Test if the input to a decision tree is an array of the given length + + + + + Test if the input to a decision tree matches the given constructor + + + + + + + + + + + + + + Bind the given value throught the remaining cases of the dtree. + + + + + Indicates the decision tree has terminated with success, calling the given target with the given parameters + + + + + Indicates a decision point in a decision tree. + + + + + Decision trees. Pattern matching has been compiled down to + a decision tree by this point. The right-hand-sides (actions) of + the decision tree are labelled by integers that are unique for that + particular tree. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Constants in expressions + + + + + + + + AttribNamedArg(name,type,isField,value) + + + + + + + + We keep both source expression and evaluated expression around to help intellisense and signature printing + + + + + + + + Attrib(kind,unnamedArgs,propVal,appliedToAGetterOrSetter,range) + + + + + Indicates an attribute refers to a type defined in an imported F# assembly + + + + + Indicates an attribute refers to a type defined in an imported .NET assembly + + + + + + + + + + + + + + + + + + + + + + + + + + + + + The result of attempting to resolve an assembly name to a full ccu. + UnresolvedCcu will contain the name of the assembly that could not be resolved. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Ensure the ccu is derefable in advance. Supply a path to attach to any resulting error message. + + + + + + + + + + + A relinkable handle to the contents of a compilation unit. Relinking is performed by mutation. + + + + + + + + + + + + + + A helper function used to link method signatures using type equality. This is effectively a forward call to the type equality + logic in tastops.fs + + + + + A handle to the full specification of the contents of the module contained in this ccu + + + + + Indicates that this DLL uses quotation literals somewhere. This is used to implement a restriction on static linking + + + + + Indicates that this DLL was compiled using the F# compiler + + + + + A hint as to where does the code for the CCU live (e.g what was the tcConfig.implicitIncludeDir at compilation time for this DLL?) + + + + + The fully qualified assembly reference string to refer to this assembly. This is persisted in quotations + + + + + A unique stamp for this DLL + + + + + Holds the data indicating how this assembly/module is referenced from the code being compiled. + + + + + Holds the filename for the DLL, if any + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Indicates the type is a variable type, whether declared, generalized or an inference type parameter + + + + + Indicates the type is a non-F#-visible type representing a "proof" that a union value belongs to a particular union case + These types are not user-visible and will never appear as an inferred type. They are the types given to + the temporaries arising out of pattern matching on union values. + + + + + Indicates the type is a function type + + + + + Indicates the type is a tuple type + + + + + Indicates the type is a type application + + + + + Indicates the type is a universal type, only used for types of values, members and record fields + + + + + The algebra of types + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Indicates a reference to something bound in another CCU + + + + + Indicates a reference to something bound in this CCU + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + References are either local or nonlocal + + + + + + + + note: ModuleOrNamespaceRef and TyconRef are type equivalent + + + + + Indicates a reference to something bound in another CCU + + + + + Indicates a reference to something bound in this CCU + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Is the destination assembly available? + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Index into the namespace/module structure of a particular CCU + + + + + + + + + + + + + + The information ILXGEN needs about the location of an item + + + + + + + + + + + + + + + + + A public path records where a construct lives within the global namespace + of a CCU. + + + + + The name of the value, or the full signature of the member + + + + + A reference to the entity containing the value or member. THis will always be a non-local reference + + + + + + + + + + + + + + + + + + + + + + + Gets updated with 'true' if an abstract slot is implemented in the file being typechecked. Internal only. + + + + + Gets updated with full slotsig after interface implementation relation is checked + + + + + The parent type. For an extension member this is the type being extended + + + + + + + + XML documentation signature for the value + + + + + XML documentation attached to a value. + + + + + + + + Top level values have an arity inferred and/or specified + signatures. The arity records the number of arguments preferred + in each position for a curried functions. The currying is based + on the number of lambdas, and in each position the elements are + based on attempting to deconstruct the type of the argument as a + tuple-type. The field is mutable because arities for recursive + values are only inferred after the r.h.s. is analyzed, but the + value itself is created before the r.h.s. is analyzed. + + TLR also sets this for inner bindings that it wants to + represent as "top level" bindings. + + + + + Custom attributes attached to the value. These contain references to other values (i.e. constructors in types). Mutable to fixup + these value references after copying a colelction of values. + + + + + Is the value actually an instance method/property/event that augments + a type, and if so what name does it take in the IL? + + + + + How visible is this? + + + + + What is the original, unoptimized, closed-term definition, if any? + Used to implement [<ReflectedDefinition>] + + + + + + + + See vflags section further below for encoding/decodings here + + + + + + + + + + + + + + + + + + + + + + + + + + + + +Get the signature for the value's XML documentation + + + + +Get the signature for the value's XML documentation + + + + + Get the declared documentation for the value + + + + + Get the type of the value including any generic type parameters + + + + + The type of the value. + May be a Type_forall for a generic value. + May be a type variable or type containing type variables during type inference. + + + + + Get the generic type parameters for the value + + + + + + + + Get the actual parent entity for the value (a module or a type), i.e. the entity under which the + value will appear in compiled code. For extension members this is the module where the extension member + is declared. + + + + + Get the type of the value after removing any generic type parameters + + + + + A unique stamp within the context of this invocation of the compiler process + + + + + + + + Get the information about the value used during type inference + + + + + The place where the value was defined. + + + + + Get the public path to the value, if any? Should be set if and only if + IsMemberOrModuleBinding is set. + + + + + - If this is a property then this is 'Foo' + - If this is an implementation of an abstract slot then this is the name of the property implemented by the abstract slot + + + + + Does the value allow the use of an explicit type instantiation (i.e. does it itself have explciti type arguments, + or does it have a signature?) + + + + + Does the inline declaration for the value indicate that the value must be inlined? + + + + + Is this a member, if so some more data about the member. + + Note, the value may still be (a) an extension member or (b) and abtract slot without + a true body. These cases are often causes of bugs in the compiler. + + + + + Get the apparent parent entity for a member + + + + + Was the value inferred to be a method or function that definitely makes no critical tailcalls? + + + + + The name of the method. + - If this is a property then this is 'get_Foo' or 'set_Foo' + - If this is an implementation of an abstract slot then this is the name of the method implemented by the abstract slot + - If this is an extension member then this will be the simple name + + + + + The value of a value or member marked with [<LiteralAttribute>] + + + + + + + + + + + + + + Was this member declared 'override' or is it an implementation of an interface slot + + + + + Was the value declared 'mutable' + + + + + Is this a value in a module, or an extension member, but excluding compiler generated bindings from optimizations + + + + + Is this a member definition or module definition? + + + + + Is this a member, if so some more data about the member. + + Note, the value may still be (a) an extension member or (b) and abtract slot without + a true body. These cases are often causes of bugs in the compiler. + + + + + + + + Is this a member, excluding extension members + + + + + Is this an instance member. + + Note, the value may still be (a) an extension member or (b) and abtract slot without + a true body. These cases are often causes of bugs in the compiler. + + + + + Is this a member generated from the de-sugaring of 'let' function bindings in the implicit class syntax? + + + + + Is this a constructor member generated from the de-sugaring of implicit constructor for a class type? + + + + + + + + + + + Is this a 'new' constructor member + + + + + Was the value generated by the compiler? + + Note: this is true for the overrides generated by hash/compare augmentations + + + + + Is this something compiled into a module, i.e. a user-defined value, an extension member or a compiler-generated value + + + + + Is this represented as a "top level" static binding (i.e. a static field, static member, + instance member), rather than an "inner" binding that may result in a closure. + + This is implied by IsMemberOrModuleBinding, however not vice versa, for two reasons. + Some optimizations mutate this value when they decide to change the representation of a + binding to be IsCompiledAsTopLevel. Second, even immediately after type checking we expect + some non-module, non-member bindings to be marked IsCompiledAsTopLevel, e.g. 'y' in + 'let x = let y = 1 in y + y' (NOTE: check this, don't take it as gospel) + + + + + Was the value ever referenced? + + + + + Is this a compiler-generated class constructor member + + + + + Get the inline declaration on the value + + + + + + + + Was the value ever referenced? + + + + + - If this is a property then this is 'Foo' + - If this is an implementation of an abstract slot then this is the name of the method implemented by the abstract slot + - If this is an operator then this is '(+)' + + + + + Range of the definition (implementation) of the value, used by Visual Studio + Updated by mutation when the implementation is matched against the signature. + + + + + The name of the method. + - If this is a property then this is 'Foo' + - If this is an implementation of an abstract slot then this is the name of the method implemented by the abstract slot + - If this is an operator then this is 'op_Addition' + + + + + The name of the method in compiled code (with some exceptions where ilxgen.fs decides not to use a method impl) + - If this is a property then this is 'get_Foo' or 'set_Foo' + - If this is an implementation of an abstract slot then this may be a mangled name + - If this is an extension member then this will be a mangled name + - If this is an operator then this is 'op_Addition' + + + + + Is this a 'base' or 'this' value? + + + + + Get the declared attributes for the value + + + + + Get the apparent parent entity for the value, i.e. the entity under with which the + value is associated. For extension members this is the nominal type the member extends. + For other values it is just the actual parent. + + + + + The parent type or module, if any (None for expression bindings and parameters) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Indicates the signature of a member constraint. Contains a mutable solution cell + to store the inferred solution of the constraint. + + + + + + + + + + + + + + + + + The specification of a member constraint that must be solved + + + + + Indicates a constraint that a type is .NET unmanaged type + + + + + Indicates a constraint that a type is a delegate from the given tuple of args to the given return type + + + + + Indicates a constraint that a type does not have the Equality(false) attribute, or is not a structural type with this attribute, with special rules for some known structural container types + + + + + Indicates a constraint that a type implements IComparable, with special rules for some known structural container types + + + + + Indicates a constraint that a type is an enum with the given underlying + + + + + Indicates a constraint that a type has a parameterless constructor + + + + + Indicates a constraint that a type is a simple choice between one of the given ground types. See format.fs + + + + + Indicates a constraint that a type is a reference type + + + + + Indicates a constraint that a type is a non-Nullable value type + These are part of .NET's model of generic constraints, and in order to + generate verifiable code we must attach them to F# generalzied type variables as well. + + + + + Indicates a constraint that a type has a member with the given signature + + + + + Indicates a constraint that a type has a 'null' value + + + + + Indicates a default value for an inference type variable should it be netiher generalized nor solved + + + + + Indicates a constraint that a type is a subtype of the given type + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + The inferred constraints for the type inference variable + + + + + An inferred equivalence for a type inference variable. + + + + + The declared attributes of the type parameter. Empty for type inference variables. + + + + + The documentation for the type parameter. Empty for type inference variables. + + + + + The unique stamp of the typar blob. + + + + + + + + + + + + + + + + + Indicates the construct can only be accessed from any code in the given type constructor, module or assembly. [] indicates global scope. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Mutation used during compilation of FSharp.Core.dll + + + + + + + + + + + + + + + + + + + + + + + + + + Namespace or module-compiled-as-type? + + + + + + + + + + + + + + + + + + + + + + + Values, including members in F# types in this module-or-namespace-fragment. + + + + + + + + + + + Type, mapping mangled name to Tycon, e.g. + + + + + + + + + + + + + + + + + Mutation used during compilation of FSharp.Core.dll + + + + + + + + + + + + + + Indicates that a 'module' is really a namespace + + + + + Indicates that a module is compiled to a class with the same name as the original module + + + + + Indicates that a module is compiled to a class with the "Module" suffix added. + + + + + + + + Indicates that an exception is abstract, i.e. is in a signature file, and we do not know the representation + + + + + Indicates that an exception carries the given record of values + + + + + Indicates that an exception is shorthand for the given .NET exception type + + + + + Indicates that an exception is an abbreviation for the given exception + + + + + + + + Name/declaration-location of the field + + + + + Attributes attached to generated field + + + + + Attributes attached to generated property + + + + + Indicates the declared visibility of the field, not taking signatures into account + + + + + The default initialization info, for static literals + + + + + Indicates a compiler generated field, not visible to Intellisense or name resolution + + + + + Indicates a volatile field + + + + + Indicates a static field + + + + + The type of the field, w.r.t. the generic parameters of the enclosing type constructor + + + + + XML Documentation signature for the field + + + + + Documentation for the field + + + + + Is the field declared mutable in F#? + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + This may represent a "field" in either a struct, class, record or union + It is normally compiled to a property. + + + + + Attributes, attached to the generated static method to make instances of the case + + + + + Indicates the declared visibility of the union constructor, not taking signatures into account + + + + + Name/range of the case + + + + + XML documentation signature for the case + + + + + Documentation for the case + + + + + Name of the case in generated IL code + + + + + Return type constructed by the case. Normally exactly the type of the enclosing type, sometimes an abbreviation of it + + + + + Data carried by the case. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + The cases contained in the discriminated union. + + + + + The ILX data structure representing the discriminated union. + + + + + + + + The cases of the discriminated union, indexed by name. + + + + + The cases of the discriminated union, in declaration order. + + + + + + + + + + + + + + The fields of the record, indexed by name. + + + + + The fields of the record, in declaration order. + + + + + + + + + + + + + + + + + + + + + + + The fields of the class, struct or enum + + + + + The declared abstract slots of the class, interface or struct + + + + + Indicates whether the type declaration is a class, interface, enum, delegate or struct + + + + + + + + Indicates the type is an enumeration + + + + + Indicates the type is a delegate with the given Invoke signature + + + + + Indicates the type is a struct + + + + + Indicates the type is an interface + + + + + Indicates the type is a class (also used for units-of-measure) + + + + + + + + Indicates the type is parameterized on a measure (e.g. float<_>) but erases to some other type (e.g. float) + + + + + Indicates the type is implemented as IL assembly code using the given closed Abstract IL type + + + + + Indicates the type is a .NET type + + + + + Indicates the type is a discriminated union + + + + + Indicates the type is a record + + + + + Indicates the type is a class, struct, enum, delegate or interface + + + + + + + + Set to true if the type is determined to be abstract + + + + + Set to true at the end of the scope where proper augmentations are allowed + + + + + Super type, if any + + + + + Interface implementations - boolean indicates compiler-generated + + + + + Properties, methods etc. as lookup table + + + + + Properties, methods etc. in declaration order + + + + + True if the type defined an Object.GetHashCode method. In this + case we give a warning if we auto-generate a hash method since the semantics may not match up + + + + + This is the value implementing the auto-generated comparison + semantics if any. It is not present if the type defines its own implementation + of IStructuralEquatable or if the type doesn't implement IComparable implicitly. + + + + + This is the value implementing the auto-generated equality + semantics if any. It is not present if the type defines its own implementation + of Object.Equals or if the type doesn't override Object.Equals implicitly. + + + + + This is the value implementing the auto-generated comparison + semantics if any. It is not present if the type defines its own implementation + of IStructuralComparable or if the type doesn't implement IComparable implicitly. + + + + + This is the value implementing the auto-generated comparison + semantics if any. It is not present if the type defines its own implementation + of IComparable or if the type doesn't implement IComparable implicitly. + + + + + + + + + + + + + + + + + Used during codegen to hold the ILX representation indicating how to access the type + + + + + The stable path to the type, e.g. Microsoft.FSharp.Core.FSharpFunc`2 + + + + + + + + The stable path to the type, e.g. Microsoft.FSharp.Core.FSharpFunc`2 + + + + + The XML document signature for this entity + + + + + The declared documentation for the type or module + + + + + This field is used when the 'tycon' is really a module definition. It holds statically nested type definitions and nested modules + + + + + Field used when the 'tycon' is really an exception definition + + + + + The methods and properties of the type + + + + + If non-None, indicates the type is an abbreviation for another type. + + + + + The declared representation of the type, i.e. record, union, class etc. + + + + + The declared attributes for the type + + + + + The declared accessibility of the representation, not taking signatures into account + + + + + The declaration location for the type constructor + + + + + The name of the type, possibly with `n mangling + + + + + The name of the type, possibly with `n mangling + + + + + The unique stamp of the "tycon blob". Note the same tycon in signature and implementation get different stamps + + + + + + + + + + + The declared type parameters of the type + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Note: result is alphabetically sorted, then for each name the results are in declaration order + + + + + Note: result is a indexed table, and for each name the results are in reverse declaration order + + + + + + + + + + + + + + + + + + + + Indicates the type prefers the "tycon<a,b>" syntax for display etc. + + + + + + + + Indicates the "tycon blob" is actually a module + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + From TAST TyconRef to IL ILTypeRef + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Get the flags as included in the F# binary metadata + + + + + + + + + + + + + + + + + + + + Encode entity flags into a bit field. We leave lots of space to allow for future expansion. + + + + + + + + + + + + + + Get the flags as included in the F# binary metadata. We pickle this as int64 to allow for future expansion + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Encode typar flags into a bit field + + + + + Indicates the type parameter derives from an '_' anonymous type + For units-of-measure, we give a warning if this gets solved to '1' + + + + + Indicates the type parameter is an inference variable may be solved + + + + + Indicates we give a warning if the type parameter is ever solved + + + + + Indicates the type parameter can't be solved, but the variable is not set to "rigid" until after inference is complete + + + + + Indicates the type parameter can't be solved + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Get the flags as included in the F# binary metadata + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Indicates the 'this' value specified in a memberm e.g. 'x' in 'member x.M() = 1' + + + + + Indicates a normal value + + + + + Indicates the value called 'base' available for calling base class members + + + + + Indicates a ref-cell holding 'this' or the implicit 'this' used throughout an + implicit constructor to access and set values + + + + + + + + Indicates the type parameter is needed at runtime and may not be eliminated + + + + + Indicates the type parameter is not needed at runtime and may be eliminated + + + + + + + + + + + + + + + + + The normal value for this flag when the value is not within its recursive scope + + + + + Set while the value is within its recursive scope. The flag indicates if the value has been eagerly generalized and accepts generic-recursive calls + + + + + + + + + + + + + + Indictes the value is inlined but the code for the function still exists, e.g. to satisfy interfaces on objects, but that it is also always inlined + + + + + Indicates the value must always be inlined + + + + + + + + + + + + + + Unique name generator for stamps attached to lambdas and object expressions + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Primitive routine to compare two EntityRef's for equality + This takes into account the possibility that they may have type forwarders + + + + + This predicate tests if non-local resolution paths are definitely known to resolve + to different entities. All references with different named paths always resolve to + different entities. Two references with the same named paths may resolve to the same + entities even if they reference through different CCUs, because one reference + may be forwarded to another via a .NET TypeForwarder. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Equality on CCU references, implemented as reference equality except when unresolved + + + + + + + + + + + + + + + + + + + + + + + Unique name generator for stamps attached to to val_specs, tycon_specs etc. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Metadata on values (names of arguments etc. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/packages/FSPowerPack.Community.2.0.0.0/Lib/Net20/FSharp.PowerPack.dll b/packages/FSPowerPack.Community.2.0.0.0/Lib/Net20/FSharp.PowerPack.dll new file mode 100644 index 0000000000000000000000000000000000000000..0e4b2eb7940ad53fd00f446b7b392b9430189cb4 Binary files /dev/null and b/packages/FSPowerPack.Community.2.0.0.0/Lib/Net20/FSharp.PowerPack.dll differ diff --git a/packages/FSPowerPack.Community.2.0.0.0/Lib/Net20/FSharp.PowerPack.xml b/packages/FSPowerPack.Community.2.0.0.0/Lib/Net20/FSharp.PowerPack.xml new file mode 100644 index 0000000000000000000000000000000000000000..0293bac7a5062e7ae5c0117482d4c977cd8eb480 --- /dev/null +++ b/packages/FSPowerPack.Community.2.0.0.0/Lib/Net20/FSharp.PowerPack.xml @@ -0,0 +1,5118 @@ + + +FSharp.PowerPack + + + + Lookup or set the given element in the table. Set replaces all existing bindings for a value with a single + bindings. Raise <c>KeyNotFoundException</c> if the element is not found. + + + + + Lookup or set the given element in the table. Set replaces all existing bindings for a value with a single + bindings. Raise <c>KeyNotFoundException</c> if the element is not found. + + + + + The total number of keys in the hash table + + + + + Lookup the given element in the table, returning the result as an Option + + + + + Replace the latest binding (if any) for the given element. + + + + + Remove the latest binding (if any) for the given element from the table + + + + +Apply the given function to each binding in the hash table + + + + + Apply the given function to each element in the collection threading the accumulating parameter + through the sequence of function applications + + + + + Find all bindings for the given element in the table, if any + + + + + + + + + + + + + + Make a shallow copy of the collection + + + + + Test if the collection contains any bindings for the given element + + + + + Clear all elements from the collection + + + + + Add a binding for the element to the table + + + + + + + + + + + + + + Build a map that contains the bindings of the given IEnumerable + + + + + Create a new empty mutable HashMultiMap with an internal bucket array of the given approximate size + and with the given key hash/equality functions + + + + + Create a new empty mutable HashMultiMap with the given key hash/equality functions + + + + + Hash tables, by default based on F# structural "hash" and (=) functions. + The table may map a single key to multiple bindings. + + + + + The total number of elements in the set + + + + + Remove the given element from the set + + + + + Apply the given function to each binding in the hash table + + + + + Apply the given function to the set threading the accumulating parameter + through the sequence of function applications + + + + + Make a shallow copy of the set + + + + + Test if the set contains the given element + + + + + Clear all elements from the set + + + + + Add an element to the collection + + + + + + + + + + + + + + Create a new mutable hash set with the given elements and using the given key hash/equality functions + + + + + Create a new empty mutable hash set with an internal bucket array of the given approximate size + and with the given key hash/equality functions + + + + + Create a new empty mutable hash set using the given key hash/equality functions + + + + + Mutable hash sets based by default on F# structural "hash" and (=) functions. Implemented via a hash table and/or Dictionary. + + + + + LazyLists are possibly-infinite, cached sequences. See also IEnumerable/Seq for + uncached sequences. LazyLists normally involve delayed computations without + side-effects. The results of these computations are cached and evaluations will be + performed only once for each element of the lazy list. In contrast, for sequences + (IEnumerable) recomputation happens each time an enumerator is created and the sequence + traversed. + + LazyLists can represent cached, potentially-infinite computations. Because they are + cached they may cause memory leaks if some active code or data structure maintains a + live reference to the head of an infinite or very large lazy list while iterating it, + or if a reference is maintained after the list is no longer required. + + Lazy lists may be matched using the LazyList.Cons and LazyList.Nil active patterns. + These may force the computation of elements of the list. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Build a new collection from the given enumerable object + + + + + Return a view of the collection as an enumerable object + + + + + Build a non-lazy list from the given collection. This function will eagerly evaluate all of the + list (and thus may not terminate). + + + + + Build a collection from the given list. This function will eagerly evaluate all of the + list (and thus may not terminate). + + + + + Build an array from the given collection + + + + + Build a collection from the given array. This function will eagerly evaluate all of the + list (and thus may not terminate). + + + + + Build a new collection whose elements are the results of applying the given function + to the corresponding elements of the two collections pairwise. + + + + + Build a new collection whose elements are the results of applying the given function + to each of the elements of the collection. + + + + + Return a new list consisting of the results of applying the given accumulating function + to successive elements of the list + + + + + Apply the given function to each element of the collection. + + + + + Return a new collection which on consumption will consist of only the elements of the collection + for which the given predicate returns "true" + + + + + Return the list which contains on demand the list of elements of the list of lazy lists. + + + + + Return the list which contains on demand the pair of elements of the first and second list + + + + + Return the list which contains on demand the elements of the first list followed + by the elements of the second list + + + + + Return a list that contains the elements returned by the given computation. + The given computation is not executed until the first element on the list is + consumed. The given argument is passed to the computation. Subsequent elements + in the list are generated by again applying the residual 'b to the computation. + + + + + Return a list that is in effect the list returned by the given computation. + The given computation is not executed until the first element on the list is + consumed. + + + + + Return the list which on consumption will consist of an infinite sequence of + the given item + + + + + Return a new list which on consumption contains the given item + followed by the list returned by the given computation. The + + + + + Return a new list which contains the given item followed by the + given list. + + + + + Return the length of the list + + + + + Evaluates to the list that contains no items + + + + + Return the first element for which the given function returns <c>true</c>. + Raise <c>KeyNotFoundException</c> if no such element exists. + + + + + Apply the given function to successive elements of the list, returning the first + result where function returns <c>Some(x)</c> for some x. If the function never returns + true, 'None' is returned. + + + + + Return the list which on consumption will skip the first 'n' elements of + the input list. + + + + + Return the list which on consumption will consist of at most 'n' elements of + the input list. + + + + + Get the first cell of the list. + + + + + Return the list corresponding to the remaining items in the sequence. + Forces the evaluation of the first cell of the list if it is not already evaluated. + + + + + Return the first element of the list. Forces the evaluation of + the first cell of the list if it is not already evaluated. + + + + + Test if a list is empty. Forces the evaluation of + the first element of the stream if it is not already evaluated. + + + + + + + + Split an array of pairs into two arrays + + + + + Combine the two arrays into an array of pairs. The two arrays must have equal lengths, otherwise an <c>ArgumentException</c> is + raised.. + + + + + Return the index of the first element in the array + that satisfies the given predicate. + + + + + Return the index of the first element in the array + that satisfies the given predicate. + + + + + Return an array containing the given element + + + + + Like <c>foldBack</c>, but return both the intermediary and final results + + + + + Like <c>fold</c>, but return the intermediary and final results + + + + + Build 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 <c>ArgumentException</c> is + raised. + + + + + Apply 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 <c>ArgumentException</c> is raised. + + + + + Return true if the given array is empty, otherwise false + + + + + Test elements of the two arrays pairwise to see if all pairs of elements satisfy the given predicate. + Raise ArgumentException if the arrays have different lengths. + + + + + 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 <c>ArgumentException</c> is + raised. + + + + + Apply 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 <c>ArgumentException</c> is + raised. + + + + + Apply a function to each element of the array, threading an accumulator argument + through the computation. If the input function is <c>f</c> and the elements are <c>i0...iN</c> then + computes <c>f i0 (...(f iN-1 iN))</c>. Raises ArgumentException if the array has size zero. + + + + + Apply a function to each element of the array, threading an accumulator argument + through the computation. If the input function is <c>f</c> and the elements are <c>i0...iN</c> + then computes <c>f (... (f i0 i1)...) iN</c>. Raises ArgumentException if the array has size zero. + + + + + Return the index of the first element in the array + that satisfies the given predicate. Raise <c>KeyNotFoundException</c> if + none of the elements satisfy the predicate. + + + + + Return the index of the first element in the array + that satisfies the given predicate. Raise <c>KeyNotFoundException</c> if + none of the elements satisfy the predicate. + + + + + Test elements of the two arrays pairwise to see if any pair of element satisfies the given predicate. + Raise ArgumentException if the arrays have different lengths. + + + + + + + + Return a view of the array as an enumerable object + + + + + Build a ResizeArray from the given elements + + + + + Return a fixed-length array containing the elements of the input ResizeArray + + + + + Sort the elements using the key extractor and generic comparison on the keys + + + + + Sort the elements using the given comparison function + + + + +Return a new array with the elements in reverse order + + + + +Split a list of pairs into two lists + + + + +Combine the two arrays into an array of pairs. The two arrays must have equal lengths. + + + + +Apply the given function to successive elements, returning the first +result where function returns "Some(x)" for some x. + + + + +Return the first element for which the given function returns <c>true</c>. +Return None if no such element exists. + + + + +Return the first element for which the given function returns <c>true</c>. +Raise <c>KeyNotFoundException</c> if no such element exists. + + + + +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) + + + + +Split the collection into two collections, containing the +elements for which the given predicate returns <c>true</c> and <c>false</c> +respectively + + + + +Return a new collection containing only the elements of the collection +for which the given predicate returns <c>true</c> + + + + + Test if all elements of the array satisfy the given predicate. + If the input function is <c>f</c> and the elements are <c>i0...iN</c> and "j0...jN" + then computes <c>p i0 && ... && p iN</c>. + + + + + Test if any element of the array satisfies the given predicate. + If the input function is <c>f</c> and the elements are <c>i0...iN</c> + then computes <c>p i0 or ... or p iN</c>. + + + + +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. + + + + +Apply the given function to each element of the array. The integer passed to the +function indicates the index of element. + + + + +Build 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. + + + + +Apply the given function to two arrays simultaneously. The +two arrays must have the same lengths, otherwise an Invalid_argument exception is +raised. + + + + +Build a new array whose elements are the results of applying the given function +to each of the elements of the array. + + + + +Apply the given function to each element of the array. + + + + + Apply a function to each element of the array, threading an accumulator argument + through the computation. If the input function is <c>f</c> and the elements are <c>i0...iN</c> then + computes <c>f i0 (...(f iN s))</c>. + + + + + Apply a function to each element of the collection, threading an accumulator argument + through the computation. If the input function is <c>f</c> and the elements are <c>i0...iN</c> + then computes <c>f (... (f s i0)...) iN</c> + + + + +Build and array from the given seq + + + + + + + +Build an array from the given list + + + + + + + +Build a list from the given array + + + + +Read a range of elements from the first array and write them into the second. + + + + +Fill a range of the collection with the given element + + + + +Build a new array that contains the elements of the given array + + + + +Build a new array that contains the given subrange specified by +starting index and length. + + + + +Build a new array that contains the elements of each of the given list of arrays + + + + +Build a new array that contains the elements of the first array followed by the elements of the second array + + + + + Create an array by calling the given generator on each index. + + + + + Create an array whose elements are all initially the given value. + + + + + Set the value of an element in the collection. You can also use the syntax <c>arr.[idx] <- e</c>. + + + + + Fetch an element from the collection. You can also use the syntax <c>arr.[idx]</c>. + + + + + Return the length of the collection. You can also use property <c>arr.Length</c>. + + + + + Generic operations on the type System.Collections.Generic.List, which is called ResizeArray in the F# libraries. + + + + + + + + Lookup or set the given element in the table. Raise <c>KeyNotFoundException</c> if the element is not found. + + + + + Lookup or set the given element in the table. Raise <c>KeyNotFoundException</c> if the element is not found. + + + + + The number of bindings in the hash table + + + + + Lookup the given element in the table, returning the result as an Option + + + + + Replace the latest binding (if any) for the given element. + + + + + Remove the latest binding (if any) for the given element from the table + + + + + Apply the given function to each binding in the hash table + + + + + Apply the given function to each element in the collection threading the accumulating parameter + through the sequence of function applications + + + + + Find all bindings for the given element in the table, if any + + + + + Create a new empty mutable hash table with an internal bucket array of the given approximate size + and with the given key hash/equality functions + + + + + Make a shallow copy of the collection + + + + + Test if the collection contains any bindings for the given element + + + + + Test if the collection contains any bindings for the given element + + + + + Clear all elements from the collection + + + + + Add a binding for the element to the table + + + + + HashMultiMap, but where a constraint tag tracks information about the hash/equality functions used + for the hashing. When the tag is Tags.StructuralHash this is identical to HashMultiMap. + + + + + + + + The number of elements in the set + + + + + Remove the given element from the set + + + + + Apply the given function to each binding in the hash table + + + + + Apply the given function to the set threading the accumulating parameter + through the sequence of function applications + + + + + Create a new empty mutable hash set with an internal bucket array of the given approximate size + and with the given key hash/equality functions + + + + + Make a shallow copy of the set + + + + + Test if the set contains the given element + + + + + Clear all elements from the set + + + + + Add an element to the collection + + + + + Mutable hash sets where a constraint tag tracks information about the hash/equality functions used + for the hashing. When the tag is Tags.StructuralHash this is identical to HashSet. + + + + + + + + Lookup an element in the map. Raise <c>KeyNotFoundException</c> if no binding + exists in the map. + + + + + Gets a value indicating whether there are no bindings in the map. + + + + + The number of bindings in the map + + + + + Gets the comparer used for the map. + + + + + Lookup an element in the map, returning a <c>Some</c> value if the element is in the domain + of the map and <c>None</c> if not. + + + + + The elements of the set as a list. + + + + + The elements of the set as an array + + + + + Remove an element from the domain of the map. No exception is raised if the element is not present. + + + + + Build two new maps, one containing the bindings for which the given predicate returns 'true', + and the other the remaining bindings. + + + + + Build a new collection whose elements are the results of applying the given function + to each of the elements of the collection. + + + + + Build a new collection whose elements are the results of applying the given function + to each of the elements of the collection. The index passed to the + function indicates the index of element being transformed. + + + + + Apply the given function to each binding in the dictionary + + + + + + + + Return true if the given predicate returns true for all of the + bindings in the map. Always returns true if the map is empty. + + + + + Given the start and end points of a key range, + Fold over the bindings in the map that are in the range, + and the end points are included if present (the range is considered a closed interval). + + + + + Fold over the bindings in the map. + + + + + Fold over the bindings in the map. + + + + + Search the map looking for the first element where the given function returns a <c>Some</c> value + + + + + Build a new map containing the bindings for which the given predicate returns 'true'. + + + + + Return true if the given predicate returns true for one of the + bindings in the map. Always returns false if the map is empty. + + + + + + + + The empty map, and use the given comparer comparison function for all operations associated + with any maps built from this map. + + + + + Build a map that contains the bindings of the given IEnumerable + and where comparison of elements is based on the given comparison function + + + + + Test is an element is in the domain of the map + + + + + Return a new map with the binding added to the given map. + + + + + Immutable maps. Keys are ordered by construction function specified + when creating empty maps or by F# structural comparison if no + construction function is specified. + + <performance> + Maps based on structural comparison are + efficient for small keys. They are not a suitable choice if keys are recursive data structures + or require non-structural comparison semantics. + </performance> + Immutable maps. A constraint tag carries information about the class of key-comparers being used. + + + + + + + + Return a new set with the elements of the second set removed from the first. + + + + + Compute the union of the two 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. + + + + + Return the number of elements in the set + + + + + Gets the comparer used for the set. + + + + + The number of elements in the set + + + + + Compute the union of the two sets. + + + + + The elements of the set as a list. + + + + + The elements of the set as an array. + + + + + A singleton set based on the given comparison operator + + + + + 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. + + + + + Build two new sets, one containing the elements for which the given predicate returns 'true', + and the other the remaining elements. + + + + + Apply the given function to each binding in the collection + + + + + Evaluates to "true" if all elements of the first set are in the second + + + + + Evaluates to "true" if all elements of the second set are in the first + + + + + Compute the intersection of the two sets. + + + + + Test if all elements of the collection satisfy the given predicate. + If the input function is <c>f</c> and the elements are <c>i0...iN</c> and <c>j0...jN</c> then + computes <c>p i0 && ... && p iN</c>. + + + + + Apply the given accumulating function to all the elements of the set + + + + + Return a new collection containing only the elements of the collection + for which the given predicate returns "true" + + + + + Test if any element of the collection satisfies the given predicate. + If the input function is <c>f</c> and the elements are <c>i0...iN</c> then computes + <c>p i0 or ... or p iN</c>. + + + + + + + + Compares two sets and returns true if they are equal or false otherwise + + + + + The empty set based on the given comparer + + + + + Return a new set with the elements of the second set removed from the first. + + + + + A set based on the given comparer containing the given initial elements + + + + + A useful shortcut for Set.contains. See the Set module for further operations on sets. + + + + + Compares a and b and returns 1 if a > b, -1 if b < a and 0 if a = b + + + + + A useful shortcut for Set.add. Note this operation prodcues 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. + + + + + Immutable sets based on binary trees, default tag + Immutable sets where a constraint tag carries information about the class of key-comparer being used. + + + + + Wait for the result and commit it + + + + + Record the result in the AsyncResultCell. Subsequent sets of the result are ignored. + + This may result in the scheduled resumption of a waiting asynchronous operation + + + + + Create a new result cell + + + + + A helper type to store a single result from an asynchronous computation and asynchronously + access its result. + + + + + + + + + + + + + + Create an async whose result depends on the value of an AsyncResult. + + + + + Represents the reified result of an asynchronous computation + + + + + An async that produces true if the reader is at the end of stream and false otherwise + + Note that when the async is run it reflects the reader state at the time of running; multiple runs will + yield different results. + + + + + + + + + + + Creates an async that read all characters in the stream up to the end. + + Note that when the async is run it reflects the reader state at the time of running; multiple runs will + yield different results. + + + + + Creates an async that reads next line from the stream + + Note that when the async is run it reflects the reader state at the time of running; multiple runs will + yield different results. + + + + + Creates an async that reads exactly <c>count</c> characters from the stream unless end of stream is reached and puts them + into <c>buffer</c> starting at <c>index</c>. The async returns the number of characters that are read (if end-of-stream is not reached + that will be <c>count</c> + + Note that when the async is run it reflects the reader state at the time of running; multiple runs will + yield different results. + + + + + Creates an async that reads all the charactes that are avilable in the stream up to <c>count</c characters and puts them + into <c>buffer</c> starting at <c>index</c>. The async returns the number of characters that are read. + + Note that when the async is run it reflects the reader state at the time of running; multiple runs will + yield different results. + + + + + Creates an async that reads next character from the stream + + Note that when the async is run it reflects the reader state at the time of running; multiple runs will + yield different results. + + + + + Creates an async that produces next character from the stream without advancing the stream + + Note that when the async is run it reflects the reader state at the time of running; multiple runs will + yield different results. + + + + +. DiscardBufferedData tells StreamReader to throw away its internal +. buffer contents. This is useful if the user needs to seek on the + underlying stream to a known location then wants the StreamReader + to start reading from this new point. This method should be called + very sparingly, if ever, since it can lead to very poor performance. + However, it may be the only way of handling some scenarios where + users need to re-read the contents of a StreamReader a second time. + + + + + + + + + + + + + + + + + + + + Creates a new AsyncStreamReader for the given stream. The + character encoding is set by encoding and the buffer size, + in number of 16-bit characters, is set by bufferSize. + + Note that detectEncodingFromByteOrderMarks is a very + loose attempt at detecting the encoding by looking at the first + 3 bytes of the stream. It will recognize UTF-8, little endian + unicode, and big endian unicode text, but that's it. If neither + of those three match, it will use the Encoding you provided. + + + + + Implements a TextReader-like API that asynchronously reads characters from + a byte stream in a particular encoding. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + See Lazy.Force + + + + + + + + + + + Return the given rational number + + + + + Return the negation of a rational number + + + + + Return the difference of two rational numbers + + + + + Return the product of two rational numbers + + + + + This operator is for use from other .NET languages + + + + + This operator is for use from other .NET languages + + + + + This operator is for use from other .NET languages + + + + + This operator is for use from other .NET languages + + + + + This operator is for use from other .NET languages + + + + + Return the result of converting the given rational number to an integer + + + + + Return the result of converting the given rational number to a big integer + + + + + Return the result of converting the given rational number to a floating point number + + + + + This operator is for use from other .NET languages + + + + + Return the ratio of two rational numbers + + + + + Return the sum of two rational numbers + + + + + Get zero as a rational number + + + + + + + + Return the sign of a rational number; 0, +1 or -1 + + + + + Get one as a rational number + + + + + Return the numerator of the normalized rational number + + + + + Return a boolean indicating if this rational number is strictly positive + + + + + Return a boolean indicating if this rational number is strictly negative + + + + + Return the denominator of the normalized rational number + + + + + + + + Return the result of converting the given rational number to an integer + + + + + Return the result of converting the given rational number to a floating point number + + + + + Return the result of converting the given rational number to a big integer + + + + + Return the result of raising the given rational number to the given power + + + + + Return the result of converting the string to a rational number + + + + + + + + Return the result of converting the given integer to a rational number + + + + + Return the result of converting the given big integer to a rational number + + + + + Return the absolute value of a rational number + + + + + The type of arbitrary-sized rational numbers + + + + + Unary negation of a complex number + + + + + Subtract one complex number from another + + + + + Multiply a complex number by a scalar + + + + + Multiply a scalar by a complex number + + + + + Multiply two complex numbers + + + + + Complex division of two complex numbers + + + + + Add two complex numbers + + + + + The real part of a complex number + + + + + The imaginary part of a complex number + + + + + The complex number 0+0i + + + + + The real part of a complex number + + + + + The polar-coordinate phase of a complex number + + + + + The complex number 0+1i + + + + + The complex number 1+0i + + + + + The polar-coordinate magnitude of a complex number + + + + + The imaginary part of a complex number + + + + + The conjugate of a complex number, i.e. x-yi + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Create a complex number using magnitude/phase polar coordinates + + + + + Create a complex number x+ij using rectangular coordinates + + + + + + + + Computes the absolute value of a complex number: e.g. Abs x+iy = sqrt(x**2.0 + y**2.0.) + Note: Complex.Abs(z) is the same as z.Magnitude + + + + + The type of complex numbers stored as pairs of 64-bit floating point numbers in rectangular coordinates + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Get the item at the given position in a matrix + + + + + Prefix '+' operator. A nop. + + + + + Matrix negation. + + + + + Point-wise subtraction of two matrices. An InvalidArgument exception will be + raised if the dimensions do not match. + + + + + Multiply each element of a matrix by a scalar value + + + + + Multiply each element of a matrix by the given scalar value + + + + + Matrix-vector multiplication. + + + + + Matrix multiplication. An InvalidArgument exception will be + raised if the dimensions do not match. + + + + + Point-wise matrix multiplication. An InvalidArgument exception will be + raised if the dimensions do not match. + + + + + Point-wise addition of two matrices. An InvalidArgument exception will be + raised if the dimensions do not match. + + + + + Get the transpose of a matrix. + + + + + + + + Get the number of rows in a matrix + + + + + Get the number of columns in a matrix + + + + + Returns sqrt(sum(norm(x)*(norm(x))) of all the elements of a matrix. + The element type of a matrix must have an associated instance of INormFloat<'T> (see <c>GlobalAssociations</c>) ((else NotSupportedException)). + + + + + Return the non-zero entries of a sparse or dense matrix + + + + + Get the item at the given position in a matrix + + + + + Indicates if a matrix uses the sparse representation. + + + + + Indicates if a matrix uses the dense representation. + + + + + Get the internal array of values for a sparse matrix. This property + should only be used when interoperating with other matrix libraries. + + + + + Get the internal array of row offsets for a sparse matrix. This property + should only be used when interoperating with other matrix libraries. + + + + + Get the internal array of column values for a sparse matrix. This property + should only be used when interoperating with other matrix libraries. + + + + + Get the internal array of values for a dense matrix. This property + should only be used when interoperating with other matrix libraries. + + + + + Retrieve the dictionary of numeric operations associated with the element + type of this matrix. Accessing the property may raise an NotSupportedException if the element + type doesn't support any numeric operations. The object returned + may support additional numeric operations such as IFractional: + this can be determined by a dynamic type test against the object + returned. + + + + + Get the number of (rows,columns) in a matrix + + + + + Get the main diagonal of a matrix, as a vector + + + + + Convert a matrix to a column vector + + + + + Convert a matrix to a row vector + + + + + Return a new array containing the elements of a matrix + + + + + + + + Supports the slicing syntax 'A.[idx1..idx2,idx1..idx2] <- B' + + + + + Select a range of rows from a matrix + + + + + Select a row from a matrix + + + + + Select a region from a matrix + + + + + Permutes the rows of a matrix. + + + + + Permutes the columns of a matrix. + + + + + Supports the slicing syntax 'A.[idx1..idx2,idx1..idx2]' + + + + + + + + Return the nth diagonal of a matrix, as a vector. Diagonal 0 is the primary + diagonal, positive diagonals are further to the upper-right of a matrix. + + + + + + + + Create a new matrix that is a copy of an array + + + + + Select a range of columns from a matrix + + + + + Select a column from a matrix + + + + + The type of matrices. The arithmetic operations on the element type are determined by inspection on the element type itself. + Two representations are supported: sparse and dense. + + + + + A permutation of a finite range of integers 0 .. N-1, represented by a mapping of index positions + + + + + + + + Return a row vector, unchanged + + + + + Point-wise negation of a row vector + + + + + Point-wise subtraction of two row vectors + + + + + Multiply a scalar by a row vector + + + + + Multiply a row vector by a scalar + + + + + Multiply a row vector by a matrix + + + + + Multiply a row vector by a vector + + + + + Point-wise multiplication of two row vectors + + + + + Point-wise addition of two row vectors + + + + + Get the transpose of the row vector. + + + + + + + + + + + + + + + + + Get the underlying internal array of values for a vector. This property + should only be used when interoperating with other matrix libraries. + + + + + + + + Return a new array containing a copy of the elements of a vector + + + + + Supports the slicing syntax 'rv.[idx1..idx2] <- rv2' + + + + + Permute the elements of the row vector. + + + + + Supports the slicing syntax 'rv.[idx1..idx2]' + + + + + + + + + + + Create a new matrix that is a copy of a array + + + + + The type of row vectors. + + + + + Gets an item from a vector + + + + + Return the input vector + + + + + Negate a vector + + + + + Subtract two vectors, pointwise + + + + + Multiply a vector by a scalar + + + + + Multiply a column vector and a row vector to produce a matrix + + + + + Multiply each element of a vector by a scalar value. + + + + + Point-wise multiplication of two vectors. + + + + + Add two vectors, pointwise + + + + + Get the transpose of a vector. + + + + + + + + Gets the number of rows in a vector + + + + + Computes the 2-norm of a vector: sqrt(x.Transpose*x). + + + + + Gets the number of entries in a vector + + + + + Gets an item from a vector + + + + + Get the underlying internal array of values for a vector. This property + should only be used when interoperating with other matrix libraries. + + + + + Gets the element operations for the element type of a vector, if any + + + + + Return a new array containing a copy of the elements of a vector + + + + + Supports the slicing syntax 'v.[idx1..idx2] <- v2' + + + + + Permute the elements of a vector. + + + + + Supports the slicing syntax 'v.[idx1..idx2]' + + + + + + + + + + + Create a new matrix that is a copy of a array + + + + + The type of column vectors. The arithmetic operations on the element type are determined by inspection + on the element type itself + + + + + + + + The type of complex numbers + + + + + The type of floating point matrices + + + + + + + + The type of floating point row vectors + + + + + The type of floating point column vectors + + + + + Tagent + + + + + Cosine + + + + + Sine + + + + + sqrt(x) and 0 <= phase(x) < pi + + + + + log(x) is natural log (base e) + + + + + exp(x) = e^x + + + + + pi + + + + + Multiply a complex number by a scalar + + + + + Multiply a scalar by a complex number + + + + + Unary negation of a complex number + + + + + Complex division of two complex numbers + + + + + Multiply two complex numbers + + + + + Subtract one complex number from another + + + + + Add two complex numbers + + + + + The complex number 0+1i + + + + + The complex number 1+0i + + + + + The complex number 0+0i + + + + + The conjugate of a complex number, i.e. x-yi + + + + + A complex of magnitude 1 and the given phase and , i.e. cis x = mkPolar 1.0 x + + + + + Create a complex number using magnitude/phase polar coordinates + + + + + The imaginary part of a complex number + + + + + The real part of a complex number + + + + + The polar-coordinate phase of a complex number + + + + + The polar-coordinate magnitude of a complex number + + + + + + + + + + + Constructs a complex number from both the real and imaginary part. + + + + + + + + Record an AppDomain-wide association between the given type and the given dictionary of + numeric operations. Raise an error if an existing association already exists. + + + + + + + + Attempt to determine a numeric association for the given type, i.e. a registered dictionary of + numeric operations. The interface can be queried dynamically for additional functionality in the numerics + hierarchy. + + + + + Associations are a way of associating dictionaries of + operations with given types at runtime. Associations are global to a + .NET application domain. Once specified an association may not be deleted + or modified. + + In this release the system of associations is simply + limited to a registry of types that support dictionaries (i.e. interface objects) + of numeric operations. The following types are pre-registered with associated numeric + operations: float, int32, int64, bigint, float32, Complex, bignum. Other types must be + registered explicitly by user code. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + In-place subtraction, mutating the first matrix argument. + + + + + In-place addition, mutating the first matrix argument. + + + + + Create a new matrix that is a copy of the given array + + + + + Map the given indexed function over each element of a matrix, producing a new matrix + + + + + Map a function over each element of a matrix, producing a new matrix + + + + + Fold a function down a particular row of a matrix + + + + + Fold a function along a particular column of a matrix + + + + + Fold a function along each row of a matrix + + + + + Fold a function down each column of a matrix + + + + + Fold an indexed function over all elements of a matrix + + + + + Fold a function over all elements of a matrix + + + + + Check if a predicate holds for at least one element of a matrix + + + + + Check if a predicate holds for all elements of a matrix + + + + + Check if a predicate holds for at least one element of a matrix + + + + + Check if a predicate holds for all elements of a matrix + + + + +sqrt(sum(x*x)) of all the elements of a matrix + + + + +Multiply all the elements of a matrix + + + + + Sum all the elements of a matrix + + + + + Generate a new matrix of the same size as the input with random entries + drawn from the range 0..aij. Random numbers are generated using a globally + shared System.Random instance with the initial seed 99. + + + + + Sum of the diagonal elements of a matrix + + + + + Transpose of a matrix. Use also m.Transpose + + + + + Point-wise exponential of a matrix. + + + + + Dot product + + + + + Add two matrices (operator +) + + + + + Point-wise minimum element of two matrices + + + + + Point-wise maximum element of two matrices + + + + + Ensure that a matrix uses dense representation + + + + + Return the first column of a matrix + + + + + Return the first row of a matrix + + + + + Return the element at row 0, column 0 of a matrix + + + + + Create a matrix with one column from the given vector + + + + + Create a matrix with one row from the given row vector + + + + + Create a 1x1 matrix containing the given value + + + + + Return a new array containing the elements of the given matrix + + + + + Create a matrix from the given data + + + + + Create a matrix from the given data + + + + + Create a matrix from the given data + + + + + Create a square matrix with a vector lying on diagonal + + + + + Create a square matrix with the constant 1.0 lying on diagonal + + + + + Create a matrix with all entries zero + + + + + Create a sparse representation matrix with the given entries. Not all + operations are available for sparse matrices, and mutation is not permitted. + If an operation on sparse matrices raises a runtime exception then consider + converting to a dense matrix using to_dense. + + + + + Create a dense representation matrix with the given entries. + + + + + Create a matrix with all entries the given constant + + + + + + + + Set an element of a matrix + + + + + Get an element of a matrix + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Subtract the second matrix from the first, by mutating the first + + + + + Add the second matrix to the first by, mutating the first + + + + + Map the given position-indexed function over a matrix + + + + + Map a function over a matrix + + + + + Create a new matrix that is a copy of the given array + + + + + Return true if an indexed predicate returns true for some value in a matrix + + + + + Return true if an indexed predicate returns true for all values in a matrix + + + + + Return true if a predicate returns true for some value in a matrix + + + + + Return true if a predicate returns true for all values in a matrix + + + + + Fold an indexed function over all elements of a matrix + + + + + Fold a function over all elements of a matrix + + + + + Returns sqrt(sum(norm(x)*(norm(x))) of all the elements of a matrix. + The element type of a matrix must have an associated instance of INormFloat<'T> (see <c>GlobalAssociations</c>) ((else NotSupportedException)). + + + + + Compute the product of the elements in a matrix + + + + + Compute the sum of the elements in a matrix + + + + + Compute the sum of the diagonal of a square matrix + + + + + Return a new matrix which is the transpose of the input matrix + + + + + Sum of the point-wise multiple of the two matrices. + The element type of a matrix must have an associated instance of INumeric<'T> (see <c>GlobalAssociations</c>) ((else NotSupportedException)). + + + + +Take the pointwise maximum of two matrices + + + + +Take the pointwise maximum of two matrices + + + + + Create a matrix containing the given vector along the diagonal. + The element type of a matrix must have an associated instance of INumeric<'T> (see <c>GlobalAssociations</c>) ((else NotSupportedException)). + + + + + Create a square matrix with the one for the element type lying on diagonal + The element type of a matrix must have an associated instance of INumeric<'T> (see <c>GlobalAssociations</c>) ((else NotSupportedException)). + + + + + Create a matrix containing the zero element at each index. + The element type of a matrix must have an associated instance of INumeric<'T> (see <c>GlobalAssociations</c>) ((else NotSupportedException)). + + + + + Create a matrix using a function to compute the item at each index. + The element type of a matrix must have an associated instance of INumeric<'T> (see <c>GlobalAssociations</c>) ((else NotSupportedException)). + The function is passed the dictionary of associated operations in addition to the index pair. + + + + + Create a matrix using a function to compute the item at each index. + + + + + Extract the first column of a matrix + + + + + Extract the first row of a matrix + + + + + Get the element at column zero, row zero + + + + + Create a matrix from a column vector + + + + + Create a matrix from a row vector + + + + + Create a 1x1 matrix containing the given value + + + + + Create a sparse matrix from the given sequence of elements + + + + + Create a dense matrix from the given sequence of elements + + + + + Create a matrix containing the given value at every element. + + + + + Return a new array containing the elements of the given matrix + + + + + Create a matrix from the given data + + + + + Create a matrix from the given data + + + + + Create a matrix from the given data + + + + + Set an element in a matrix. The indexes are given in row/column order. + + + + + Get an element from a matrix. The indexes are given in row/column order. + + + + + Operations to manipulate matrix types carrying + arbitrary element types. The names and types of the operations match those + in the containing module Math.Matrix. + + The numeric operations on the element type (add, zero etc.) are inferred from the type + argument itself. That is, for some operations + the element type of a matrix must have an associated instance of INumeric<'T> + or some more specific numeric association (see <c>GlobalAssociations</c>) ((else NotSupportedException)). + + + + + Operations to manipulate floating + point matrices. The submodule <c>Matrix.Generic</c> contains a + matching set of operations to manipulate matrix types carrying + arbitrary element types. + + + + + Builds a (row) vector from a sequence of floats. + + + + + Builds a (column) vector from a sequence of floats. + + + + + Builds a matrix from a sequence of sequence of floats. + + + + + + + Version of System.Single.NaN that is generic in its units-of-measure + + + Version of System.Single.PositiveInfinity that is generic in its units-of-measure + + + Version of System.Double.NaN that is generic in its units-of-measure + + + Version of System.Double.PositiveInfinity that is generic in its units-of-measure + + + + + + + + + + + + + + + + + + + + + + + + + + + + The identity permutation over any size + + + + + Return a permutation that rotates right by the given distance. If the distance + is negative then a left rotation results. + + + + + Return a permutation that, when applied, maps index 0 to size-1, size-1 to 0 etc. + + + + + Return a swaps the given two elements over any size + + + + + + + + Create a permutation by specifying (source,destination) index pairs. For example, + Permutation(3,[ (0,2);(1,0); (2,1) ]) specifies a permutation that rotates + all elements left one place. Not all elements need be given, e.g. + Permutation(5,[ (1,2);(2,1) |]) specifies a permutation that swaps elements at indexes + 1 and 2. + + + + + + + + Create a permutation by specifying the result of permuting [| 0 .. n-1 |]. For example, + Permutation.ofArray [| 1;2;0 |] specifies a permutation that rotates all elements right one place. + + + + + + + + Unified atomic mass unit + + + + + Electron volt + + + + + Stefan-Boltzmann constant + + + + + Boltzmann constant R/N_A + + + + + Molar gas constant + + + + + Faraday constant + + + + + Avogadro constant + + + + + Rydberg constant + + + + + Fine-structure constant + + + + + Proton mass + + + + + Electron mass + + + + + Conductance quantum 2e^2/h + + + + + Magnetic flux quantum h/2e + + + + + Elementary charge + + + + + Dirac constant, also known as the reduced Planck constant = h/2pi + + + + + Planck constant + + + + + Newtonian constant of gravitation + + + + + electric constant = 1/(mu0 c^2) + + + + + magnetic constant + + + + + speed of light in vacuum + + + + + Fundamental physical constants, with units-of-measure + + + + + + + + + + + + + + + + + Return a new array containing a copy of the elements of the given vector + + + + + Create a vector from an array of double precision floats + + + + + Create a vector from a sequence of numbers + + + + + Create a vector from a list of numbers + + + + + + + + + + + Return a vector of the given length where every entry is zero. + + + + + Create by comprehension + + + + + Create by constant initialization + + + + + Get the dimensions (number of rows) of a column rowvec. + + + + + Set an element of a column rowvec + + + + + Get an element of a column vector + + + + + + + + + + + + + + + + + + + + Return a new array containing a copy of the elements of the given vector + + + + + Create a row vector from an array of elements + + + + + Create a row vector from a sequence of elements + + + + + Create a row vector from a list of elements + + + + + Return a vector of the given length where every entry is zero. + + + + + Create by constant initialization + + + + + Create by comprehension + + + + + Transpose the row vector + + + + + Get the number of rows in a column vector. + + + + + Set an element in a column vector. + + + + + Get an element from a column vector. + + + + + Operations to manipulate row vectors types carrying + arbitrary element types. + + + + + Operations to manipulate floating + point row vectors. These are included for completeness and are + nearly always transposed to column vectors. + + + + + katal, SI unit of catalytic activity + + + + + sievert, SI unit of does equivalent + + + + + gray, SI unit of absorbed dose + + + + + becquerel, SI unit of activity referred to a radionuclide + + + + + lux, SI unit of illuminance + + + + + lumen, SI unit of luminous flux + + + + + henry, SI unit of inductance + + + + + tesla, SI unit of magnetic flux density + + + + + weber, SI unit of magnetic flux + + + + + siemens, SI unit of electric conductance + + + + + ohm, SI unit of electric resistance + + + + + farad, SI unit of capacitance + + + + + volt, SI unit of electric potential difference, electromotive force + + + + + coulomb, SI unit of electric charge, amount of electricity + + + + + watt, SI unit of power, radiant flux + + + + + joule, SI unit of energy, work, amount of heat + + + + + pascal, SI unit of pressure, stress + + + + + newton, SI unit of force + + + + + hertz, SI unit of frequency + + + + + candela, SI unit of luminous intensity + + + + + mole, SI unit of amount of substance + + + + + kelvin, SI unit of thermodynamic temperature + + + + + ampere, SI unit of electric current + + + + + second, SI unit of time + + + + + kilogram, SI unit of mass + + + + + metre (or meter), SI unit of length + + + + + The International System of Units (SI) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Map an indexed function over each element of a vector + + + + + Map a function over each element of a vector + + + + + Copy a vector + + + + + Fold an indexed function over all elements of a vector + + + + + Fold a function over all elements of a vector + + + + + Return true if an indexed predicate returns true for some value in a vector + + + + + Return true if an indexed predicate returns true for all values in a vector + + + + + Return true if a predicate returns true for some value in a vector + + + + + Return true if a predicate returns true for all values in a vector + + + + + Computes the 2-norm of a vector: sqrt(x.Transpose*x). + + + + +Multiply all the elements of a matrix + + + + +Sum all the elements of a vector + + + + +Transpose of a matrix. Use also m.Transpose + + + + +Point-wise exponential of a vector. + + + + +Dot product + + + + + Create a vector that represents a integral mesh over the given range + e.g. range 1 5 = vector [ 1.;2.;3.;4.;5. ] + + + + + Create a vector that represents a mesh over the given range + e.g. rangef (-1.0) 0.5 1.0 = vector [ -1.0; -0.5; 0.0; 0.5; 1.0] + + + + + Return a vector of the given length where every entry is zero. + + + + + Generate a vector of the given length where each entry contains the given value + + + + + Create a 1-element vector + + + + + Return a new array containing a copy of the elements of the given vector + + + + + Create a vector from an array of double precision floats + + + + + Create a vector from a sequence of numbers + + + + + Create a vector from a list of numbers + + + + + Create a vector of a fixed length using a function to compute the initial element values + + + + + Get the dimensions (number of rows) of a column vector. Identical to <c>nrows</c> + + + + + Set an element of a column vector + + + + + Get an element of a column vector + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Map an indexed function over each element of a vector + + + + + Map a function over each element of a vector + + + + + Copy the vector + + + + + Fold an indexed function over all elements of a vector + + + + + Fold a function over all elements of a vector + + + + + Return true if an indexed predicate returns true for some value in a vector + + + + + Return true if an indexed predicate returns true for all values in a vector + + + + + Return true if a predicate returns true for some value in a vector + + + + + Return true if a predicate returns true for all values in a vector + + + + + Computes the 2-norm of a vector: sqrt(x.Transpose*x). + + + + +Multiply all the elements of a matrix + + + + +Sum all the elements of a vector + + + + +Dot product + + + + +Take the pointwise minimum of two vectors + + + + +Take the pointwise maximum of two vectors + + + + + Return a vector of the given length where every entry is zero. + + + + + Generate a vector of the given length where each entry contains the given value + + + + + Return a new array containing a copy of the elements of the given vector + + + + + Create a vector from an array of elements + + + + + Create a 1-element vector + + + + + Create a vector from a sequence of numbers + + + + + Create a vector from a list of numbers + + + + + Creation: useful when the element type has associated operations. + + + + + Creation: general + + + + + Get the dimensions (number of rows) of a column vector. Identical to <c>nrows</c> + + + + + Set an element of a column vector + + + + + Get an element of a column vector + + + + + Operations to manipulate column vectors carrying + arbitrary element types. + + + + + Operations to manipulate floating + point column vectors. The submodule VectorOps.Generic contains a + matching set of operations to manipulate column vectors carrying + arbitrary element types. + + + + + See NativeArray2 + + + + + Get or set an entry in the array + + + + + + + + + + + + + + View a FortranMatrix as a CMatrix. Doesn't actually allocate + a new matirx - just gives a different label to the same bits, and swaps the + row/column count information associated with the bits. + + + + + Get or set an entry in the array + + + + + + + + This type wraps a pointer to a blob of unmanaged memory assumed to contain + a Fortran-style column major two-dimensional matrix of items compatible with the (presumably blittable) + type 'T. The blob of memory must be allocated and managed externally, + e.g. by a computation routine written in C. + + All operations on this type are marked inlined + because the code used to implement the operations is not verifiable. + + Any code that uses these operations will be unverifiable and may + cause memory corruption if not used with extreme care. + + + + + Get or set an entry in the array + + + + + Pointer to the C-style row major two-dimensional array + + + + + Get the number of rows of the native array + + + + + Get the number of columns of the native array + + + + + View a CMatrix as a FortranMatrix. Doesn't actually allocate + a new matirx - just gives a different label to the same bits, and swaps the + row/column count information associated with the bits. + + + + + Get or set an entry in the array + + + + + Creates a C-style row major two-dimensional array from a native pointer, the number of rows and the number of columns. + Nothing is actually copied. + + + + + This type wraps a pointer to a blob of unmanaged memory assumed to contain + a C-style row major two-dimensional matrix of items compatible with the (presumably blittable) + type 'T. The blob of memory must be allocated and managed externally, + e.g. by a computation routine written in C. + + All operations on this type are marked inlined + because the code used to implement the operations is not verifiable. + + Any code that uses these operations will be unverifiable and may + cause memory corruption if not used with extreme care. + + + + + Get or set an entry in the array + + + + + Pointer to the C-style one-dimensional array + + + + + Length of the C-style one-dimensional array + + + + + Get or set an entry in the array + + + + + Creates a C-style one dimensional array from a native pointer and the length of the array + Nothing is actually copied. + + + + + This type wraps a pointer to a blob of unmanaged memory assumed to contain + a C-style one-dimensional array of items compatible with the (presumably blittable) + type 'T. The blob of memory must be allocated and managed externally, + e.g. by a computation routine written in C. + + All operations on this type are marked inlined + because the code used to implement the operations is not verifiable. + + Any code that uses these operations will be unverifiable and may + cause memory corruption if not used with extreme care. + + + + + For native interop. Pin the given object + + + + + For native interop. Pin the given object + + + + + + + + + + + + + + + + + + + + + + + Represents a pinned handle to a structure with an underlying 2D array, i.e. an underlying NativeArray2. + Used when interfacing with native code math libraries such as LAPACK. + + + + + For native interop. Pin the given object + + + + + + + + + + + + + + + + + + + + Represents a pinned handle to a structure with an underlying 1D array, i.e. an underlying NativeArray. + Used when interfacing with native code math libraries such as LAPACK. + + + + + + + + Pin the given ref for the duration of a single call to the given function. A native pointer to + the contents of the ref is passed to the given function. Cleanup the GCHandle associated with the + pin when the function completes, even if an exception is raised. + + + + + + + + Return the name of the argument + + + + + Return the usage help associated with the argument + + + + + Return the argument type and action of the argument + + + + + + + + + + + Prints the help for each argument. + + + + + Parse some of the arguments given by 'argv', starting at the given position + + + + + Parse the arguments given by System.Environment.GetEnvironmentVariables() + according to the argument processing specifications "specs". + Args begin with "-". Non-arguments are passed to "f" in + order. "use" is printed as part of the usage line if an error occurs. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + The spec value describes the action of the argument, + and whether it expects a following parameter. + + + + + Interpret tables for a unicode lexer generated by fslex. + + + + + + + + Interpret tables for a unicode lexer generated by fslex, processing input asynchronously + + + + + The type of tables for an unicode lexer generated by fslex. + + + + + Interpret tables for an ascii lexer generated by fslex. + + + + + + + + Interpret tables for an ascii lexer generated by fslex, processing input asynchronously + + + + + The type of tables for an ascii lexer generated by fslex. + + + + + The start position for the lexeme + + + + + True if the refill of the buffer ever failed , or if explicitly set to true. + + + + + The end position for the lexeme + + + + + The start position for the lexeme + + + + + The length of the matched string + + + + + The matched string + + + + + True if the refill of the buffer ever failed , or if explicitly set to true. + + + + + The end position for the lexeme + + + + + Dynamically typed, non-lexically scoped parameter table + + + + + Fast helper to turn the matched characters into a string, avoiding an intermediate array + + + + + Fetch a particular character in the matched string + + + + + Create a lex buffer suitable for use with a Unicode lexer that reads character inputs from the given text reader + + + + + Create a lex buffer suitable for Unicode lexing that reads characters from the given string + + + + + Create a lex buffer that reads character or byte inputs by using the given function + + + + + Create a lex buffer suitable for Unicode lexing that reads characters from the given array + + + + + + + + Create a lex buffer suitable for byte lexing that reads characters from the given array + + + + + + + + Create a lex buffer suitable for use with ASCII byte lexing that reads byte inputs from the given binary reader + + + + + Create a lex buffer that asynchronously reads character or byte inputs by using the given function + + + + + Remove all input, though don't discard the current lexeme + + + + + Input buffers consumed by lexers generated by <c>fslex.exe </c> + + + + + The absolute offset of the column for the position + + + + + The absolute offset of the beginning of the line + + + + + The line number for the position + + + + + The file name for the position + + + + + Return absolute offset of the start of the line marked by the position + + + + + + + + The line number in the input stream, assuming fresh positions have been updated + using AsNewLinePos() and by modifying the EndPos property of the LexBuffer. + + + + + The file name associated with the input stream. + + + + + Get an arbitrary position, with the empty string as filename, and + + + + + Return the column number marked by the position, i.e. the difference between the AbsoluteOffset and the StartOfLineAbsoluteOffset + + + + + + + + The character number in the input stream + + + + + Gives a position shifted by specified number of characters + + + + + Get a position corresponding to the first line (line number 1) in a given file + + + + + Given a position at the start of a token of length n, return a position just beyond the end of the token + + + + + + + + Position information stored for lexing tokens + + + + + The tag of the error terminal + + + + + The total number of terminals + + + + + This function is used to hold the user specified "parse_error" or "parse_error_rich" functions + + + + + This table is logically part of the Goto table + + + + + The sparse table offsets for the productions active for each state + + + + + The sparse table for the productions active for each state + + + + + The sparse goto table row offsets + + + + + The sparse goto table + + + + + The immediate action table + + + + + The number of symbols for each reduction + + + + + The sparse action table row offsets + + + + + The sparse action table elements + + + + + A function to compute the data carried by a token + + + + + A function to compute the tag of a token + + + + + The token number indicating the end of input + + + + + The reduction table + + + + + Interpret the parser table taking input from the given lexer, using the given lex buffer, and the given start state. + Returns an object indicating the final synthesized value for the parse. + + + + + Tables generated by fsyacc + The type of the tables contained in a file produced by the fsyacc.exe parser generator. + + + + + The stack of state indexes active at the parse error + + + + + The token that would cause a shift at the parse error + + + + + The stack of productions that would be reduced at the parse error + + + + + The tokens that would cause a reduction at the parse error + + + + + The state active at the parse error + + + + + The message associated with the parse error + + + + + The token that caused the parse error + + + + + The context provided when a parse error occurs + + + + + Get the full range of positions matched by the production + + + + + Get the store of local values associated with this parser + + + + + Raise an error in this parse context + + + + + Get the start position for the terminal or non-terminal at a given index matched by the production + + + + + Get the start and end position for the terminal or non-terminal at a given index matched by the production + + + + + Get the end position for the terminal or non-terminal at a given index matched by the production + + + + + Get the value produced by the terminal or non-terminal at the given position + + + + + The information accessible via the <c>parseState</c> value within parser actions. + + + + + Indicates a parse error has occured and parse recovery is in progress + + + + + + + + Indicates an accept action has occured + + + + + The default implementation of the parse_error function + + + + + The default implementation of the parse_error_rich function + + + + + Helpers used by generated parsers. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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> + + + + + The maximum number of rows for which to generate layout for table-like + structures. -1 if no maximum. + + + + + The maximum number of elements for which to generate layout for + list-like structures, or columns in table-like + structures. -1 if no maximum. + + + + + Return to the layout-generation + environment to layout any otherwise uninterpreted object + + + + + + + + + + + + + + + + + Data representing structured layouts of terms. The representation + of this data type is only for the consumption of formatting engines. + + + + + + + + + + + + + + Data representing joints in structured layouts of terms. The representation + of this data type is only for the consumption of formatting engines. + + + + + 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. + + + + diff --git a/packages/FSPowerPack.Community.2.0.0.0/Lib/Net40/FSharp.PowerPack.Linq.dll b/packages/FSPowerPack.Community.2.0.0.0/Lib/Net40/FSharp.PowerPack.Linq.dll new file mode 100644 index 0000000000000000000000000000000000000000..b6081b4b1f45022e46adabad1d55ebebf178449e Binary files /dev/null and b/packages/FSPowerPack.Community.2.0.0.0/Lib/Net40/FSharp.PowerPack.Linq.dll differ diff --git a/packages/FSPowerPack.Community.2.0.0.0/Lib/Net40/FSharp.PowerPack.Linq.xml b/packages/FSPowerPack.Community.2.0.0.0/Lib/Net40/FSharp.PowerPack.Linq.xml new file mode 100644 index 0000000000000000000000000000000000000000..594ab5a3cb15157e8be384371287c079b1c7fba7 --- /dev/null +++ b/packages/FSPowerPack.Community.2.0.0.0/Lib/Net40/FSharp.PowerPack.Linq.xml @@ -0,0 +1,367 @@ + + +FSharp.PowerPack.Linq + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Convert the quotation expression to LINQ expression trees + + This operation will only succeed for a subset of quotation expressions. + + Exceptions: InvalidArgumentException will be raised if the input expression is + not in the subset that can be converted to a LINQ expression tree + + + + + + + + Compile the quotation expression by first converting to LINQ expression trees + + Exceptions: InvalidArgumentException will be raised if the input expression is + not in the subset that can be converted to a LINQ expression tree + + + + + Evaluate the quotation expression by first converting to LINQ expression trees + + Exceptions: InvalidArgumentException will be raised if the input expression is + not in the subset that can be converted to a LINQ expression tree + + + + + Compile the quotation expression by first converting to LINQ expression trees + + Exceptions: InvalidArgumentException will be raised if the input expression is + not in the subset that can be converted to a LINQ expression tree + + + + + Compile the quotation expression by first converting to LINQ expression trees + + Exceptions: InvalidArgumentException will be raised if the input expression is + not in the subset that can be converted to a LINQ expression tree + + + + + + + + An intrinsic for compiling <c>&lt;@ x <> y @&gt;</c> to expression trees + + + + + + + + This join operator implements the LINQ GroupJoin operator and the <c>query</c> convertor recognises it as such + + + + + This join operator corresponds to the LINQ Join operator and the <c>query</c> convertor recognises it as such + + + + + When used in queries, this operator corresponds to the LINQ Join operator and the <c>query</c> convertor recognises it as such + + + + + When used in queries, this operator corresponds to the LINQ Max operator and the <c>query</c> convertor recognises it as such + It differs in return type from <c>Seq.maxBy</c> + + + + + When used in queries, this operator corresponds to the LINQ Min operator and the <c>query</c> convertor recognises it as such + It differs in return type from <c>Seq.minBy</c> + + + + + When used in queries, this operator corresponds to the LINQ Contains operator and the <c>query</c> convertor recognises it as such + + + + + Evaluate the quotation expression by first converting to a LINQ expression tree + making use of IQueryable operators and then executing expression tree + + Exceptions: <c>InvalidArgumentException</c> will be raised if the input expression is + not in the subset that can be converted to a LINQ expression tree + + + + + + + + This function should not be called directly. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + A set of types used for implementing quotation conversions. + These are public only because targets of Linq Lambda expressions require them to be so + + + + + This module provides Compile and Eval extension members + for F# quotation values, implemented by translating to LINQ + expression trees and using the LINQ dynamic compiler. + + + + diff --git a/packages/FSPowerPack.Community.2.0.0.0/Lib/Net40/FSharp.PowerPack.Metadata.dll b/packages/FSPowerPack.Community.2.0.0.0/Lib/Net40/FSharp.PowerPack.Metadata.dll new file mode 100644 index 0000000000000000000000000000000000000000..e4ff28c4c8b74896c1fa55638b9fc25a4b0431c5 Binary files /dev/null and b/packages/FSPowerPack.Community.2.0.0.0/Lib/Net40/FSharp.PowerPack.Metadata.dll differ diff --git a/packages/FSPowerPack.Community.2.0.0.0/Lib/Net40/FSharp.PowerPack.Metadata.xml b/packages/FSPowerPack.Community.2.0.0.0/Lib/Net40/FSharp.PowerPack.Metadata.xml new file mode 100644 index 0000000000000000000000000000000000000000..dae6b1cea242ad18183763349a7fdc9d5c2a427e --- /dev/null +++ b/packages/FSPowerPack.Community.2.0.0.0/Lib/Net40/FSharp.PowerPack.Metadata.xml @@ -0,0 +1,15761 @@ + + +FSharp.PowerPack.Metadata + + + + + + + + + + + + + + + + The value '%s' is not accessible from this code location + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:970) + + + + + The union cases or fields of the type '%s' are not accessible from this code location + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:969) + + + + + The union case '%s' is not accessible from this code location + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:971) + + + + + The value or constructor '%s' is not defined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:6) + + + + + The value, namespace, type or module '%s' is not defined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:7) + + + + + The value, constructor, namespace or type '%s' is not defined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:5) + + + + + The type parameter '%s' is not defined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:12) + + + + + The type '%s' is not defined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:9) + + + + + The record label or namespace '%s' is not defined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:10) + + + + + The record label '%s' is not defined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:11) + + + + + The pattern discriminator '%s' is not defined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:13) + + + + + The namespace or module '%s' is not defined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:3) + + + + + The namespace '%s' is not defined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:2) + + + + + The field, constructor or member '%s' is not defined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:4) + + + + + The constructor, module or namespace '%s' is not defined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:8) + + + + + The type '%s' implements 'System.IComparable'. Consider also adding an explicit override for 'Object.Equals' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:179) + + + + + The type '%s' implements 'System.IComparable' explicitly but provides no corresponding override for 'Object.Equals'. An implementation of 'Object.Equals' has been automatically provided, implemented via 'System.IComparable'. Consider implementing the override 'Object.Equals' explicitly + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:180) + + + + + The signature and implementation are not compatible because the respective type parameter counts differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:175) + + + + + The signature and implementation are not compatible because the type parameter '%s' has a constraint of the form %s but the implementation does not. Either remove this constraint from the signature or add it to the implementation. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:178) + + + + + The signature and implementation are not compatible because the declaration of the type parameter '%s' requires a constraint of the form %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:177) + + + + + The signature and implementation are not compatible because the type parameter in the class/signature has a different compile-time requirement to the one in the member/implementation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:176) + + + + + The override for '%s' was ambiguous + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:195) + + + + + The override '%s' implements more than one abstract slot, e.g. '%s' and '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:198) + + + + + No implementations of '%s' had the correct number of arguments and type parameters. The required signature is '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:194) + + + + + No implementation was given for '%s'. Note that all interface members must be implemented and listed under an appropriate 'interface' declaration, e.g. 'interface ... with member ...'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:203) + + + + + No implementation was given for '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:202) + + + + + The interface '%s' is included in multiple explicitly implemented interface types. Add an explicit implementation of this interface. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:200) + + + + + A named argument has been assigned more than one value + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:201) + + + + + More than one override implements '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:196) + + + + + The namespace or module attributes differ between signature and implementation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:192) + + + + + The method '%s' is sealed and cannot be overridden + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:197) + + + + + This method is over-constrained in its type parameters + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:193) + + + + + The member '%s' does not have the correct number of method type parameters. The required signature is '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:205) + + + + + The member '%s' does not have the correct number of arguments. The required signature is '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:204) + + + + + The member '%s' does not have the correct kinds of generic parameters. The required signature is '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:206) + + + + + The member '%s' cannot be used to implement '%s'. The required signature is '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:207) + + + + + Invalid value + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:174) + + + + + The struct, record or union type '%s' has an explicit implementation of 'Object.GetHashCode' or 'Object.Equals'. You must apply the 'CustomEquality' attribute to the type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:181) + + + + + The struct, record or union type '%s' has an explicit implementation of 'Object.GetHashCode'. Consider implementing a matching override for 'Object.Equals(obj)' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:182) + + + + + The struct, record or union type '%s' has an explicit implementation of 'Object.Equals'. Consider implementing a matching override for 'Object.GetHashCode()' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:183) + + + + + Duplicate or redundant interface + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:199) + + + + + The implicit instantiation of a generic construct at or near this point could not be resolved because it could resolve to multiple unrelated types, e.g. '%s' and '%s'. Consider using type annotations to resolve the ambiguity + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:169) + + + + + Could not resolve the ambiguity in the use of a generic construct with an 'unmanaged' constraint at or near this position + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1108) + + + + + Could not resolve the ambiguity inherent in the use of a 'printf'-style format string + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:171) + + + + + Could not resolve the ambiguity inherent in the use of the operator '%s' at or near this program point. Consider using type annotations to resolve the ambiguity. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:170) + + + + + Could not resolve the ambiguity in the use of a generic construct with an 'enum' constraint at or near this position + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:172) + + + + + Could not resolve the ambiguity in the use of a generic construct with a 'delegate' constraint at or near this position + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:173) + + + + + The type '%s' is not accessible from this code location + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:968) + + + + + union case + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:945) + + + + + type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:941) + + + + + property + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:950) + + + + + patvar + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:952) + + + + + and %d other overloads + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:944) + + + + + namespace/module + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:955) + + + + + namespace + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:953) + + + + + module + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:954) + + + + + inherits + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:942) + + + + + implements + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:943) + + + + + Full name + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:940) + + + + + also from %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:957) + + + + + from %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:956) + + + + + field + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:948) + + + + + event + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:949) + + + + + argument + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:951) + + + + + active recognizer + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:947) + + + + + active pattern result + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:946) + + + + + Unexpected TExpr_tchoose + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:981) + + + + + Note: Lambda-lifting optimizations have not been applied because of the use of this local constrained generic function as a first class value. Adding type constraints may resolve this condition. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:982) + + + + + The 'VolatileField' attribute may only be used on 'let' bindings in classes + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:689) + + + + + Volatile fields must be marked 'mutable' and cannot be thread-static + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:746) + + + + + A declaration may only be given a value in a signature if the declaration has the [<Literal>] attribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:744) + + + + + In sequence expressions, multiple results are generated using 'yield!' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:663) + + + + + Character range matches have been removed in F#. Consider using a 'when' pattern guard instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:596) + + + + + Use 'typeof<_>' instead + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:610) + + + + + The use of 'let! x = coll' in sequence expressions is no longer permitted. Use 'for x in coll' instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:661) + + + + + This attribute cannot be used in this version of F# + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:716) + + + + + Unrecognized attribute target. Valid attribute targets are 'assembly', 'module', 'type', 'method', 'property', 'return', 'param', 'field', 'event', 'constructor'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:706) + + + + + Unrecognized accessibility specification + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:508) + + + + + The unnamed arguments do not form a prefix of the arguments of the method called + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:683) + + + + + Unknown union case + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:534) + + + + + Unit-of-measure cannot be used in type constructor application + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:572) + + + + + This union case takes one argument + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:590) + + + + + This union case expects %d arguments in tupled form + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:591) + + + + + This union case does not take arguments + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:589) + + + + + Uninitialized 'val' fields in implicit construction types must be mutable and marked with the '[<DefaultValue>]' attribute. Consider using a 'let' binding instead of a 'val' field. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:747) + + + + + Unexpected type arguments + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:581) + + + + + Unexpected type application + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:664) + + + + + Unexpected %s in type expression + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:575) + + + + + Unexpected / in type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:580) + + + + + Unexpected source-level property specification + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:545) + + + + + Unexpected source-level property specification in syntax tree + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:539) + + + + + Unexpected Measure_Anon + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:494) + + + + + Unexpected expression at recursive inference point + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:524) + + + + + Unexpected constraints or parameters on module specification + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:787) + + + + + Unexpected constraint or type definition + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:788) + + + + + Unexpected Const_uint16array + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:499) + + + + + Unexpected Const_bytearray + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:500) + + + + + Unexpected condition in imported assembly: failed to decode AttributeUsage attribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:705) + + + + + Unexpected big rational constant + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:497) + + + + + The field '%s' has been given a value, but is not present in the type '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:629) + + + + + Unable to parse format string '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:606) + + + + + Types cannot inherit from multiple concrete types + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:797) + + + + + Types cannot contain nested type definitions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:776) + + + + + Struct types are always sealed + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:809) + + + + + Record types are always sealed + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:807) + + + + + Enum types are always sealed + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:811) + + + + + Delegate types are always sealed + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:810) + + + + + Discriminated union types are always sealed + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:806) + + + + + Assembly code types are always sealed + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:808) + + + + + The type '%s' is used in an invalid way. A value prior to '%s' has an inferred type involving '%s', which is an invalid forward reference. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:834) + + + + + This type requires a definition + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:794) + + + + + The type parameters inferred for this value are not stable under the erasure of type abbreviations. This is due to the use of type abbreviations which drop or reorder type parameters, e.g. \n\ttype taggedInt<'a> = int or\n\ttype swap<'a,'b> = 'b * 'a.\nConsider declaring the type parameters for this value explicitly, e.g.\n\tlet f<'a,'b> ((x,y) : swap<'b,'a>) : swap<'a,'b> = (y,x). + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:529) + + + + + Type parameter cannot be used as type constructor + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:576) + + + + + This type parameter has been used in a way that constrains it to always be '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:528) + + + + + This value, type or method expects %d type parameter(s) but was given %d + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:551) + + + + + type or module + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:778) + + + + + The type '%s' is not an interface type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:754) + + + + + This type is not an interface type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:771) + + + + + This type is not a record type. Values of class and struct types must be created using calls to object constructors. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:656) + + + + + This type is not a record type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:657) + + + + + This type is not accessible from this code location + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:704) + + + + + This type has no nested types + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:574) + + + + + This type has no accessible object constructors + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:667) + + + + + Fields which are type functions cannot be mutated + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:492) + + + + + type, exception or module + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:777) + + + + + Type definitions using implicit construction may only have one 'inherit' specification and it must be the first declaration + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:827) + + + + + Type definitions using implicit construction must have local let/do-bindings preceding member and interface definitions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:828) + + + + + This type definition involves an immediate cyclic reference through a struct field or inheritance relation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:823) + + + + + This type definition involves an immediate cyclic reference through an abbreviation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:822) + + + + + The type '%s' is not a type whose values can be enumerated with this syntax, i.e. is not compatible with either seq<_>, IEnumerable<_> or IEnumerable and does not have a GetEnumerator method + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:558) + + + + + Type abbreviations cannot have members + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:761) + + + + + Type abbreviations cannot have interface declarations + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:769) + + + + + Type abbreviations cannot have augmentations + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:832) + + + + + This type abbreviation has one or more declared type parameters that do not appear in the type being abbreviated. Type abbreviations must use all declared type parameters in the type being abbreviated. Consider removing one or more type parameters, or use a concrete type definition that wraps an underlying type, such as 'type C<'a> = C of ...'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:795) + + + + + 'try'/'with' cannot be used within sequence expressions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:662) + + + + + Thread-static and context-static variables must be static and given the [<DefaultValue>] attribute to indicate that the value is initialized to the default value on each new thread + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:745) + + + + + The syntax 'expr.id' may only be used with record labels, properties and fields + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:678) + + + + + Syntax error - unexpected '?' symbol + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:598) + + + + + '%s' may only be used to construct object types + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:627) + + + + + The struct, record or union type '%s' has the 'StructuralEquality' attribute but the component type '%s' does not satisfy the 'equality' constraint + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1085) + + + + + The struct, record or union type '%s' has the 'StructuralEquality' attribute but the type parameter '%s' does not satisfy the 'equality' constraint. Consider adding the 'equality' constraint to the type parameter + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1084) + + + + + The struct, record or union type '%s' has the 'StructuralComparison' attribute but the component type '%s' does not satisfy the 'comparison' constraint + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1079) + + + + + The struct, record or union type '%s' has the 'StructuralComparison' attribute but the type parameter '%s' does not satisfy the 'comparison' constraint. Consider adding the 'comparison' constraint to the type parameter + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1078) + + + + + Each argument of the primary constructor for a struct must be given a type, for example 'type S(x1:int, x2: int) = ...'. These arguments determine the fields of the struct. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1086) + + + + + Structs cannot contain 'let' bindings because the default constructor for structs will not execute these bindings. Consider adding additional arguments to the primary constructor for the type. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:765) + + + + + Structs cannot contain 'do' bindings because the default constructor for structs would not execute these bindings + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:764) + + + + + Structs, interfaces, enums and delegates cannot inherit from other types + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:796) + + + + + Structs cannot have an object constructor with no arguments. This is a restriction imposed on all CLI languages as structs automatically support a default constructor. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:737) + + + + + Structs may only bind a 'this' parameter at member declarations + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:523) + + + + + Struct types cannot contain abstract members + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:816) + + + + + Static 'val' fields in types must be mutable, private and marked with the '[<DefaultValue>]' attribute. They are initialized to the 'null' or 'zero' value for their type. Consider also using a 'static let mutable' binding in a class type. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:748) + + + + + Static optimization conditionals are only for use within the F# library + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:684) + + + + + This static member should not have a 'this' parameter. Consider using the notation 'member Member(args) = ...'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:542) + + + + + Static 'let' bindings may only be defined in class types with implicit constructors + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:766) + + + + + Interfaces cannot contain definitions of static initializers + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:732) + + + + + A static initializer requires an argument + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:540) + + + + + A static field was used where an instance field is expected + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:490) + + + + + A simple method name is required here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:636) + + + + + In sequence expressions, results are generated using 'yield' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:496) + + + + + Return values cannot have names + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:502) + + + + + Return types of union cases must be identical to the type being defined, up to abbreviations + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:752) + + + + + The syntax 'type X with ...' is reserved for augmentations. Types whose representations are hidden but which have members are now declared in signatures using 'type X = ...'. You may also need to add the '[<Sealed>] attribute to the type declaration in the signature + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:824) + + + + + This is not a variable, constant, active recognizer or literal + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:594) + + + + + This control construct may only be used if the computation expression builder defines a '%s' method + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:573) + + + + + Only active patterns returning exactly one result may accept arguments + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:586) + + + + + The representation of this type is hidden by the signature. It must be given an attribute such as [<Sealed>], [<Class>] or [<Interface>] to indicate the characteristics of the type. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:802) + + + + + Recursive bindings that include member specifications can only occur as a direct augmentation of a type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:739) + + + + + Records, union, abbreviations and struct types cannot have the 'AllowNullLiteral' attribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:798) + + + + + This record contains fields from inconsistent types + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:521) + + + + + A property cannot have explicit type parameters. Consider using a method instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:536) + + + + + This property or field was not found on this custom attribute type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:711) + + + + + Property '%s' is static + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:675) + + + + + Property '%s' is not static + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:672) + + + + + Property '%s' is not readable + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:673) + + + + + The property implemented by this default is ambiguous + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:729) + + + + + Property '%s' cannot be set + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:676) + + + + + This property cannot be set + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:710) + + + + + This property already has a default implementation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:728) + + + + + The types System.ValueType, System.Enum, System.Delegate, System.MulticastDelegate and System.Array cannot be used as super types in an object expression or class + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:637) + + + + + A parameter with attributes must also be given a name, e.g. '[<Attribute>] paramName : paramType' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:501) + + + + + The parameter '%s' was inferred to have byref type. Parameters of byref type must be given an explicit type annotation, e.g. 'x1: byref<int>'. When used, a byref parameter is implicitly dereferenced. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1103) + + + + + You must explicitly declare either all or no type parameters when overriding a generic abstract method + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:531) + + + + + Accessibility modifiers are not permitted on overrides or interface implementations + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:805) + + + + + This override takes a different number of arguments to the corresponding abstract member + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:722) + + + + + One or more of the overloads of this method has curried arguments. Consider redesigning these members to take arguments in tupled form. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:682) + + + + + Optional arguments cannot be used in custom attributes + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:709) + + + + + Optional arguments are only permitted on type members + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:582) + + + + + Optional arguments must come at the end of the argument list, after any non-optional arguments + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1122) + + + + + This declaration opens the namespace or module '%s' through a partially qualified path. Adjust this code to use the full path of the namespace. This change will make your code more robust as new constructs are added to the F# and CLI libraries. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:759) + + + + + Only types representing units-of-measure may be given the 'Measure' attribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:804) + + + + + Only structs and classes without implicit constructors may be given the 'StructLayout' attribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:801) + + + + + Only simple variable patterns can be bound in 'let rec' constructs + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:740) + + + + + Only simple bindings of the form 'id = expr' can be used in construction expressions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:643) + + + + + Only record fields and simple 'let' bindings may be marked mutable + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:741) + + + + + Only functions may be marked 'inline' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:698) + + + + + Only classes may be given the 'AbstractClass' attribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:803) + + + + + Objects must be initialized by an object construction expression that calls an inherited object constructor and assigns a value to each field + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:644) + + + + + The operator 'expr.[idx]' has been used an object of indeterminate type based on information prior to this program point. Consider adding further type constraints + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:618) + + + + + Only overrides of abstract and virtual members may be specified in object expressions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:632) + + + + + This form of object expression is not used in F#. Use 'member this.MemberName ... = ...' to define member implementations in object expressions. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:546) + + + + + Calls to object constructors on type parameters cannot be given arguments + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:620) + + + + + Interfaces cannot contain definitions of object constructors + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:733) + + + + + An object constructor requires an argument + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:541) + + + + + Object construction expressions (i.e. record expressions with inheritance specifications) may only be used to implement constructors in object model types. Use 'new ObjectType(args)' to construct instances of object model types outside of constructors + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:654) + + + + + Object construction expressions may only be used to implement constructors in class types + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:642) + + + + + This numeric literal requires that a module '%s' defining functions FromZero, FromOne, FromInt32, FromInt64 and FromString be in scope + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:650) + + + + + This is not a valid name for an enumeration case + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:611) + + + + + This code is not sufficiently generic. The type variable %s could not be generalized because it would escape its scope. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:535) + + + + + Not an exception + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:786) + + + + + Non-zero constants cannot have generic units. For generic zero, write 0.0<_>. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:495) + + + + + The generic member '%s' has been used at a non-uniform instantiation prior to this program point. Consider reordering the members so this member occurs first. Alternatively, specify the full type of the member explicitly, including argument types, return type and any additional generic parameters and constraints. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1104) + + + + + This value is not a literal and cannot be used in a pattern + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:554) + + + + + No abstract property was found that corresponds to this override + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:725) + + + + + No abstract or interface member was found that corresponds to this override + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:721) + + + + + Interface implementations cannot be given on construction expressions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:641) + + + + + The struct, record or union type '%s' does not support structural equality because the type '%s' does not satisfy the 'equality' constraint. Consider adding the 'NoEquality' attribute to the type '%s' to clarify that the type does not support structural equality + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1083) + + + + + The struct, record or union type '%s' does not support structural equality because the type parameter %s does not satisfy the 'equality' constraint. Consider adding the 'NoEquality' attribute to the type '%s' to clarify that the type does not support structural equality + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1082) + + + + + The struct, record or union type '%s' is not structurally comparable because the type '%s' does not satisfy the 'comparison' constraint. Consider adding the 'NoComparison' attribute to the type '%s' to clarify that the type is not comparable + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1081) + + + + + The struct, record or union type '%s' is not structurally comparable because the type parameter %s does not satisfy the 'comparison' constraint. Consider adding the 'NoComparison' attribute to the type '%s' to clarify that the type is not comparable + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1080) + + + + + No arguments may be given when constructing a record value + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:640) + + + + + The member '%s' does not correspond to any abstract or virtual method available to override or implement + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:633) + + + + + 'new' may only be used with object constructors + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:648) + + + + + 'new' must be used with a named type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:638) + + + + + This new member hides the abstract member '%s' once tuples, functions and/or units of measure are erased. Rename the member or use 'override' instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:731) + + + + + This new member hides the abstract member '%s'. Rename the member or use 'override' instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:730) + + + + + 'new' cannot be used on interface types. Consider using an object expression '{ new ... with ... }' instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:624) + + + + + Namespaces cannot contain values. Consider using a module to hold your value declarations. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:504) + + + + + Namespaces cannot contain extension members except in the same file and namespace where the type is defined. Consider using a module to hold declarations of extension members. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:505) + + + + + '%s' may only be used with named types + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:622) + + + + + The use of named arguments in union case expressions is reserved for future use. Arguments of the form 'a=b' should be parenthesized. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1105) + + + + + Named arguments cannot be given to member trait calls + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:609) + + + + + The named argument '%s' did not match any argument or mutable property + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:681) + + + + + Name '%s' not bound in pattern context + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:583) + + + + + Named arguments must appear after all other arguments + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:556) + + + + + Mutable function values should be written 'let mutable f = (fun args -> ...)' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:697) + + + + + Mutable values cannot have generic parameters + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:696) + + + + + Mutable values cannot be marked 'inline' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:695) + + + + + Multiple visibility attributes have been specified for this identifier. 'let' bindings in classes are always private, as are any 'let' bindings inside expressions. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:507) + + + + + Multiple visibility attributes have been specified for this identifier + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:506) + + + + + Modules cannot use named module signature definitions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:837) + + + + + This declaration opens the module '%s', which is marked as 'RequireQualifiedAccess'. Adjust your code to use qualified references to the elements of the module instead, e.g. 'List.map' instead of 'map'. This change will ensure that your code is robust as new constructs are added to libraries. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:758) + + + + + The path '%s' is a namespace. A module abbreviation may not abbreviate a namespace. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:833) + + + + + Method overrides and interface implementations are not permitted here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:720) + + + + + Method '%s' is not accessible from this code location + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:491) + + + + + Members that extend interface, delegate or enum types must be placed in a module separate to the definition of the type. This module must either have the AutoOpen attribute or be opened explicitly by client code to bring the extension members into scope. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:825) + + + + + The member '%s' is used in an invalid way. A use of '%s' has been inferred prior to the definition of '%s', which is an invalid forward reference. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:835) + + + + + Interfaces cannot contain definitions of member overrides + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:734) + + + + + Extension members cannot provide operator overloads. Consider defining the operator as part of the type definition instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1125) + + + + + This member is not permitted in an interface implementation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:774) + + + + + MemberKindPropertyGetSet only expected in parse trees + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:503) + + + + + This member is not sufficiently generic + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:742) + + + + + A member and a local class binding both have the name '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:768) + + + + + Measure definitions cannot have type parameters + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:793) + + + + + Measure declarations may have only static members: constructors are not available + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:767) + + + + + Measure declarations may have only static members + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:763) + + + + + This lookup cannot be used here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:674) + + + + + Local class bindings cannot be marked inline. Consider lifting the definition out of the class or else do not mark it as inline. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:760) + + + + + Literal values cannot have generic parameters + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:702) + + + + + A literal value cannot be marked 'mutable' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:700) + + + + + A literal value cannot be marked 'inline' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:701) + + + + + A declaration may only be the [<Literal>] attribute if a constant value is also given, e.g. 'val x : int = 1' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:743) + + + + + This list expression exceeds the maximum size for list literals. Use an array for larger literals and call Array.ToList. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:607) + + + + + 'let' and 'do' bindings are not permitted in class definitions unless an implicit construction sequence is used. You can use an implicit construction sequence by modifying the type declaration to include arguments, e.g. 'type X(args) = ...'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:831) + + + + + This code is less generic than required by its annotations because the explicit type variable '%s' could not be generalized. It was constrained to be '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:525) + + + + + The kind of the type specified by its attributes does not match the kind implied by its definition + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:792) + + + + + Invalid use of a type name and/or object constructor. If necessary use 'new' and apply the constructor to its arguments, e.g. 'new Type(args)'. Overloads are:\n\t%s. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:669) + + + + + Invalid use of a type name and/or object constructor. If necessary use 'new' and apply the constructor to its arguments, e.g. 'new Type(args)'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:668) + + + + + Invalid use of a type name + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:666) + + + + + Invalid use of an interface type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:670) + + + + + Invalid use of a delegate constructor. Use the syntax 'new Type(args)' or just 'Type(args)'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:671) + + + + + The 'UseNullAsTrueValue' attribute flag may only be used with union types that have one nullary case and at least one non-nullary case + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1102) + + + + + 'use' bindings must be of the form 'use <var> = <expr>' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:718) + + + + + Units-of-measure cannot be used as prefix arguments to a type. Rewrite as postfix arguments in angle brackets. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:571) + + + + + Units-of-measure supported only on float, float32, decimal and signed integer types + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:498) + + + + + Literal enumerations must have type int, uint, int16, uint16, int64, uint64, byte, sbyte or char + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:820) + + + + + Invalid type extension + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:790) + + + + + Type arguments cannot be specified here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:585) + + + + + Invalid signature for set member + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:727) + + + + + Invalid record, sequence or computation expression. Sequence expressions should be of the form 'seq { ... }' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:604) + + + + + Invalid record construction + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:651) + + + + + This property has an invalid type. Properties taking multiple indexer arguments should have types of the form 'ty1 * ty2 -> ty3'. Properties returning functions should have types of the form '(ty1 -> ty2)'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:566) + + + + + This is not a valid pattern + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:595) + + + + + Invalid optional assignment to a property or field + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:686) + + + + + The '%s' operator should not normally be redefined. To define overloaded comparison semantics for a particular type, implement the 'System.IComparable' interface in the definition of that type. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:513) + + + + + The '%s' operator should not normally be redefined. To define equality semantics for a type, override the 'Object.Equals' member in the definition of that type. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:514) + + + + + The '%s' operator should not normally be redefined. Consider using a different operator name + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:515) + + + + + Invalid object, sequence or record expression + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:603) + + + + + Invalid object expression. Objects without overrides or interfaces should use the expression form 'new Type(args)' without braces. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:602) + + + + + This is not a valid object construction expression. Explicit object constructors must either call an alternate constructor or initialize all fields of the object and specify a call to a super class constructor. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:561) + + + + + Non-primitive numeric literal constants cannot be used in pattern matches because they can be mapped to multiple different types through the use of a NumericLiteral module. Consider using replacing with a variable, and use 'when <variable> = <constant>' at the end of the match clause. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:584) + + + + + 'new' constraints must take one argument of type 'unit' and return the constructed type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:565) + + + + + Invalid namespace, module, type or union case name + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:750) + + + + + Invalid module name + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:789) + + + + + This recursive binding uses an invalid mixture of recursive forms + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:560) + + + + + The name '(%s)' should not be used as a member name. To define comparison semantics for a type, implement the 'System.IComparable' interface. If defining a static member for use from other CLI languages then use the name '%s' instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:509) + + + + + The name '(%s)' should not be used as a member name. To define equality semantics for a type, override the 'Object.Equals' member. If defining a static member for use from other CLI languages then use the name '%s' instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:510) + + + + + The name '(%s)' should not be used as a member name because it is given a standard definition in the F# library over fixed types + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:512) + + + + + The name '(%s)' should not be used as a member name. If defining a static member for use from other CLI languages then use the name '%s' instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:511) + + + + + Invalid inline specification + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:717) + + + + + Invalid indexer expression + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:617) + + + + + The '%s' operator cannot be redefined. Consider using a different operator name + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:516) + + + + + Internal error. Invalid index into active pattern array + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:588) + + + + + This is not a valid value for an enumeration literal + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:753) + + + + + An 'enum' constraint must be of the form 'enum<type>' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:564) + + + + + Delegate specifications must be of the form 'typ -> typ' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:818) + + + + + Invalid declaration + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:547) + + + + + Invalid constraint: the type used for the constraint is sealed, which means the constraint could only be satisfied by at most one solution + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:563) + + + + + Invalid constraint + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:562) + + + + + This is not a valid constant expression + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:703) + + + + + Invalid assignment + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:665) + + + + + Invalid argument to parameterized pattern label + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:587) + + + + + This is not a valid name for an active pattern + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:693) + + + + + Interfaces inherited by other interfaces should be declared using 'inherit ...' instead of 'interface ...' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1114) + + + + + Interface types cannot be sealed + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:817) + + + + + Interface types and delegate types cannot contain fields + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:812) + + + + + This instance member needs a parameter to represent the object being invoked. Make the member static or use the notation 'member x.Member(args) = ...'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:538) + + + + + The inherited type is not an object model type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:653) + + + + + A inheritance declaration is not permitted here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:757) + + + + + This 'inherit' declaration specifies the inherited type but no arguments. Consider supplying arguments, e.g. 'inherit BaseType(args)'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:829) + + + + + This 'inherit' construction call is not part of an implicit construction sequence. Only the inherited type should be specified at this point. Calls to the inherited constructor should be placed inside the object initialization expression of your object constructor. Alternatively use an implicit construction sequence by modifying the type declaration to include arguments, e.g. 'type X(args) = ...'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:830) + + + + + 'inherit' cannot be used on interface types. Consider implementing the interface by using 'interface ... with ... end' instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:623) + + + + + Implicit product of measures following / + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:493) + + + + + The struct, record or union type '%s' implements the interface 'System.IStructuralEquatable' explicitly. Apply the 'CustomEquality' attribute to the type. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:779) + + + + + The struct, record or union type '%s' implements the interface 'System.IStructuralComparable' explicitly. Apply the 'CustomComparison' attribute to the type. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:520) + + + + + The struct, record or union type '%s' implements the interface 'System.IEquatable<_>' explicitly. Apply the 'CustomEquality' attribute to the type and provide a consistent implementation of the non-generic override 'System.Object.Equals(obj)'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:780) + + + + + The struct, record or union type '%s' implements the interface 'System.IComparable' explicitly. You must apply the 'CustomComparison' attribute to the type. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:518) + + + + + The struct, record or union type '%s' implements the interface 'System.IComparable<_>' explicitly. You must apply the 'CustomComparison' attribute to the type, and should also provide a consistent implementation of the non-generic interface System.IComparable. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:519) + + + + + Illegal syntax in type expression + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:577) + + + + + Illegal pattern + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:597) + + + + + Explicit type declarations for constructors must be of the form 'ty1 * ... * tyN -> resTy'. Parentheses may be required around 'resTy' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:751) + + + + + A literal value cannot be given the [<ThreadStatic>] or [<ContextStatic>] attributes + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:699) + + + + + It is recommended that objects that support the IDisposable interface are created using 'new Type(args)' rather than 'Type(args)' to indicate that resources may be owned by the generated value + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:626) + + + + + Generic types cannot be given the 'StructLayout' attribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:800) + + + + + A generic type parameter has been used in a way that constrains it to always be '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:527) + + + + + The generic function '%s' must be given explicit type argument(s) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:549) + + + + + This function value is being used to construct a delegate type whose signature includes a byref argument. You must use an explicit lambda expression taking %d arguments. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:557) + + + + + The corresponding formal argument is not optional + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:685) + + + + + The field labels and expected type of this record expression or pattern do not uniquely determine a corresponding record type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:532) + + + + + A field/val declaration is not permitted here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:756) + + + + + This field requires a name + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:749) + + + + + No assignment given for field '%s' of type '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:630) + + + + + This field is not a literal and cannot be used in a pattern + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:593) + + + + + This field is readonly + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:555) + + + + + Field '%s' is not static + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:592) + + + + + This field is not mutable + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:612) + + + + + The field '%s' appears twice in this record expression or pattern + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:533) + + + + + All record, union and struct types in FSharp.Core.dll must be explicitly labelled with 'StructuralComparison' or 'NoComparison' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1077) + + + + + Extraneous fields have been given values + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:631) + + + + + This list or array expression includes an element of the form 'if ... then ... else'. Parenthesize this expression to indicate it is an individual element of the list or array, to disambiguate this from a list generated using a sequence expression + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:605) + + + + + This expression form may only be used in sequence and computation expressions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:601) + + + + + The expression form { expr with ... } may only be used with record types. To build object types use { new Type(...) with ... } + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:652) + + + + + The expression form 'expr then expr' may only be used as part of an explicit object constructor + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:608) + + + + + Expected %d expressions, got %d + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:599) + + + + + TcExprUndelayed: delayed + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:600) + + + + + Explicit type specifications cannot be used for exception constructors + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:781) + + + + + Explicit type parameters may only be used on module or member bindings + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:530) + + + + + An explicit static initializer should use the syntax 'static new(args) = expr' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:543) + + + + + Explicit signatures within implementation files may no longer be used + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:836) + + + + + An explicit object constructor should use the syntax 'new(args) = expr' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:544) + + + + + Expected unit-of-measure, not type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:570) + + + + + Expected unit-of-measure parameter, not type parameter. Explicit unit-of-measure parameters must be marked with the [<Measure>] attribute. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:567) + + + + + Expected type parameter, not unit-of-measure parameter + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:568) + + + + + Expected type, not unit-of-measure + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:569) + + + + + Expected an interface type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:645) + + + + + Expected module or namespace parent %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:517) + + + + + Exception abbreviations should not have argument lists + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:782) + + + + + Exception abbreviations must refer to existing exceptions or F# types deriving from System.Exception + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:784) + + + + + Event '%s' is static + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:679) + + + + + Event '%s' is not static + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:680) + + + + + Enumerations cannot have members + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:762) + + + + + Enumerations cannot have interface declarations + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:770) + + + + + The 'EntryPointAttribute' attribute may only be used on function definitions in modules + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:694) + + + + + '{ }' is not a valid expression. Records must include at least one field. Empty sequences are specified by using Seq.empty or an empty list '[]'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:655) + + + + + Duplicate specification of an interface + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:755) + + + + + The method or function '%s' should not be given explicit type argument(s) because it does not declare its type parameters explicitly + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:550) + + + + + 'do!' cannot be used within sequence expressions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:660) + + + + + DLLImport stubs cannot be inlined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:522) + + + + + Delegate specifications must not be curried types. Use 'typ * ... * typ -> typ' for multi-argument delegates, and 'typ -> (typ -> typ)' for delegates returning function values. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:819) + + + + + A delegate constructor must be passed a single function value + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:687) + + + + + The 'DefaultValue' attribute may only be used on 'val' declarations + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:691) + + + + + The default, zero-initializing constructor of a struct type may only be used if all the fields of the struct type admit default initialization + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:552) + + + + + A default implementation of this interface has already been added because the explicit implementation of the interface was not specified at the definition of the type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:773) + + + + + This method already has a default implementation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:723) + + + + + The method implemented by this default is ambiguous + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:724) + + + + + The declared type parameters for this type extension do not match the declared type parameters on the original type '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:826) + + + + + This declaration element is not permitted in an augmentation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:775) + + + + + A custom attribute must invoke an object constructor + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:714) + + + + + A custom attribute must be a reference type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:712) + + + + + The number of args for a custom attribute does not match the expected number of args for the attribute constructor + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:713) + + + + + Couldn't find Dispose on IDisposable, or it was overloaded + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:553) + + + + + Constructors cannot be defined for this type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:738) + + + + + Constructors cannot be specified in exception augmentations + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:736) + + + + + Constructors must be applied to arguments and cannot be used as first-class values. If necessary use an anonymous function '(fun arg1 ... argN -> new Type(arg1,...,argN))'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:677) + + + + + Constructors for the type '%s' must directly or indirectly call its implicit object constructor. Use a call to the implicit object constructor instead of a record expression. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:628) + + + + + This object constructor requires arguments + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:647) + + + + + Constructor expressions for interfaces do not take arguments + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:646) + + + + + A constructor cannot have explicit type parameters. Consider using a static construction method instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:537) + + + + + This construct may only be used within sequence or computation expressions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:615) + + + + + This construct may only be used within list, array and sequence expressions, e.g. expressions of the form 'seq { ... }', '[ ... ]' or '[| ... |]'. These use the syntax 'for ... in ... do ... yield...' to generate elements + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:613) + + + + + This construct may only be used within computation expressions. To return a value from an ordinary function simply write the expression without 'return'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:614) + + + + + This construct may only be used within computation expressions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:616) + + + + + This construct is ambiguous as part of a sequence expression. Nested expressions may be written using 'let _ = (...)' and nested sequences using 'yield! seq {... }'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:659) + + + + + This construct is ambiguous as part of a computation expression. Nested expressions may be written using 'let _ = (...)' and nested computations using 'let! res = builder { ... }'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:658) + + + + + One or more of the explicit class or function type variables for this binding could not be generalized, because they were constrained to other types + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:526) + + + + + Attribute 'System.Diagnostics.ConditionalAttribute' is only valid on methods or attribute classes + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1123) + + + + + The 'ConditionalAttribute' attribute may only be used on members + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:692) + + + + + Interfaces cannot contain definitions of concrete members. You may need to define a constructor on your type, or use implicit class construction, to indicate that the type is a concrete implementation class. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:735) + + + + + The 'CompiledName' attribute cannot be used with this language element + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:621) + + + + + Cannot inherit from a variable type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:619) + + + + + Cannot inherit a sealed type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:814) + + + + + Cannot inherit from interface type. Use interface ... with instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:815) + + + + + Cannot create an extension of a sealed type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:639) + + + + + Cannot call an abstract base member: '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1107) + + + + + A binding cannot be marked both 'use' and 'rec' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:688) + + + + + This expression has a method called GetEnumerator, but its return type is a value type. Methods returning struct enumerators cannot be used in this expression form. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:559) + + + + + The attributes of this type specify multiple kinds for the type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:791) + + + + + Attributes are not allowed within patterns + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:548) + + + + + Attributes are not permitted on 'let' bindings in expressions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:690) + + + + + This attribute is not valid for use on this language element. Assembly attributes should be attached to a 'do ()' declaration, if necessary within an F# module. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:707) + + + + + This attribute is not valid for use on this language element + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:708) + + + + + Attribute expressions must be calls to object constructors + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:715) + + + + + The attribute 'AutoOpen(\"%s\")' in the assembly '%s' did not refer to a valid module or namespace in that assembly and has been ignored + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:838) + + + + + The attribute '%s' appears in both the implementation and the signature, but the attribute arguments differ. Only the attribute from the signature will be included in the compiled code. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1106) + + + + + At least one override did not correctly implement its corresponding abstract member + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:649) + + + + + The member '%s' does not accept the correct number of arguments. One overload accepts %d arguments. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:635) + + + + + The member '%s' does not accept the correct number of arguments, %d arguments are expected + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:634) + + + + + Anonymous unit-of-measure cannot be nested inside another unit-of-measure expression + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:578) + + + + + Anonymous type variables are not permitted in this declaration + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:579) + + + + + Types with the 'AllowNullLiteral' attribute may only inherit from or implement types which also allow the use of the null literal + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:799) + + + + + All implemented interfaces should be declared on the initial declaration of the type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:772) + + + + + Instances of this type cannot be created since it has been marked abstract or not all methods have been given implementations. Consider using an object expression '{ new ... with ... }' instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:625) + + + + + This property overrides or implements an abstract property but the abstract property doesn't have a corresponding %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:726) + + + + + Abstract members are not permitted in an augmentation - they must be defined as part of the type itself + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:719) + + + + + Abbreviations for Common IL exception types must have a matching object constructor + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:785) + + + + + Abbreviations for Common IL exceptions cannot take arguments + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:783) + + + + + Abbreviated types cannot be given the 'Sealed' attribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:813) + + + + + A value must be mutable in order to mutate the contents or take the address of a value type, e.g. 'let mutable x = ...' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:88) + + + + + The value has been copied to ensure the original is not mutated by this operation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:90) + + + + + This value does not have a valid property setter type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:84) + + + + + Unexpected decode of InternalsVisibleToAttribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:95) + + + + + Unexpected decode of InterfaceDataVersionAttribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:96) + + + + + Unexpected decode of AutoOpenAttribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:94) + + + + + Unexpected use of a byref-typed variable + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:87) + + + + + The type %s did not contain the union case '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1098) + + + + + The type %s did not contain the field '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1097) + + + + + The module/namespace '%s' from compilation unit '%s' did not contain the val '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1100) + + + + + The module/namespace '%s' from compilation unit '%s' did not contain the namespace, module or type '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1101) + + + + + The module/namespace '%s' from compilation unit '%s' did not contain the module/namespace '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1099) + + + + + The type/module '%s' is not a concrete module or type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:74) + + + + + The type '%s' has an inline assembly code representation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:75) + + + + + Two modules named '%s' occur in two parts of this assembly + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:77) + + + + + Recursively defined values cannot appear directly as part of the construction of a tuple value within a recursive binding + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:91) + + + + + Recursive values cannot be directly assigned to the non-mutable field '%s' of the type '%s' within a recursive binding. Consider using a mutable field instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:93) + + + + + Recursive values cannot appear directly as a construction of the type '%s' within a recursive binding. This feature has been removed from the F# language. Consider using a record instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:92) + + + + + This is not a constant expression or valid custom attribute value + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:99) + + + + + A namespace and a module named '%s' both occur in two parts of this assembly + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:76) + + + + + Invalid mutation of a constant expression. Consider copying the expression to a mutable local, e.g. 'let mutable x = ...'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:89) + + + + + Invalid member signature encountered because of an earlier error + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:83) + + + + + Invalid form for a property setter. At least one argument is required. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:86) + + + + + Invalid form for a property getter. At least one '()' argument is required when using the explicit syntax. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:85) + + + + + This operation accesses a mutable top-level value defined in another assembly in an unsupported way. The value cannot be accessed through its address. Consider copying the expression to a mutable local, e.g. 'let mutable x = ...', and if necessary assigning the value back after the completion of the operation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1093) + + + + + Two type definitions named '%s' occur in namespace '%s' in two parts of this assembly + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:78) + + + + + This constant cannot be used as a custom attribute value + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:98) + + + + + A module and a type definition named '%s' occur in namespace '%s' in two parts of this assembly + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:79) + + + + + Active patterns cannot return more than 7 possibilities + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:97) + + + + + The struct or class field '%s' is not accessible from this code location + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:973) + + + + + If set to true, then all error messages will just return the filled 'holes' delimited by ',,,'s - this is for language-neutral testing (e.g. localization-invariant baselines). + + + + + Recursive class hierarchy in type '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:965) + + + + + Error reading/writing metadata for the F# compiled DLL '%s'. Was the DLL compiled with an earlier version of the F# compiler? (error: '%s'). + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:70) + + + + + Partial active patterns may only generate one result + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:992) + + + + + Missing variable '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:991) + + + + + Accessibility modifiers are not permitted on an 'inherits' declaration + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:436) + + + + + Accessibility modifiers should come immediately prior to the identifier naming a construct + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:407) + + + + + 'use' bindings are not permitted in modules and are treated as 'let' bindings + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:400) + + + + + 'use' bindings are not permitted in implicit class constructors + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:399) + + + + + Unmatched 'with' or badly formatted 'with' block + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:423) + + + + + Unmatched '(' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:450) + + + + + No body found for this 'let' or 'do'. The body must be indented to the same column as this line. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:449) + + + + + Unmatched 'if' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:455) + + + + + Unmatched 'class', 'interface' or 'struct' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:421) + + + + + Unmatched '[|' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:469) + + + + + Unmatched '[' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:464) + + + + + Unmatched '{' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:470) + + + + + Unmatched 'begin' or 'struct' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:414) + + + + + Unmatched 'begin' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:426) + + + + + Unmatched '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:468) + + + + + Accessibility modifiers are not permitted on union cases. Use 'type U = internal ...' or 'type U = private ...' to give an accessibility to the whole representation. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:444) + + + + + Accessibility modifiers are not permitted here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:405) + + + + + Syntax error: unexpected type parameter specification + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:481) + + + + + A semicolon is not expected at this point + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:403) + + + + + Unexpected infix operator in unit-of-measure expression. Legal operators are '*', '/' and '^'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:479) + + + + + Unexpected integer literal in unit-of-measure expression + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:480) + + + + + Unexpected integer literal in type expression + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:478) + + + + + Unexpected infix operator in type expression + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:476) + + + + + Unexpected identifier: '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:443) + + + + + Unexpected end of input + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:404) + + + + + Unexpected empty type moduleDefn list + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:416) + + + + + Unclosed 'for', e.g. no 'done' found to match this 'for' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:459) + + + + + Unclosed block + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:413) + + + + + Type annotations on property getters and setters must be given after the 'get()' or 'set(v)', e.g. 'with get() : string = ...' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:429) + + + + + Accessibility modifiers are not permitted in this position for type abbreviations + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:439) + + + + + The syntax 'module ... = struct .. end' is not used in F# code. Consider using 'module ... = begin .. end' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:485) + + + + + The syntax 'module ... : sig .. end' is not used in F# code. Consider using 'module ... = begin .. end' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:486) + + + + + Syntax error in labelled type argument + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:475) + + + + + Syntax error + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:419) + + + + + Successive patterns should be separated by spaces or tupled + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:451) + + + + + Successive arguments should be separated by spaces or tupled, and arguments involving function or method applications should be parenthesized + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:463) + + + + + A setter property may have at most two argument groups + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1090) + + + + + Property setters must be defined using 'set value = ', 'set idx value = ' or 'set (idx1,...,idxN) value = ... ' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:432) + + + + + Accessibility modifiers are not permitted on record fields. Use 'type R = internal ...' or 'type R = private ...' to give an accessibility to the whole representation. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:447) + + + + + In F# code you may use 'expr.[expr]'. A type annotation may be required to indicate the first expression is an array + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:466) + + + + + At most one 'with' augmentation is permitted + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:402) + + + + + Only '#' compiler directives may occur prior to the first 'namespace' declaration + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:406) + + + + + Only class types may take value arguments + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:425) + + + + + The use of the type syntax 'int C' and 'C <int>' is not permitted here. Consider adjusting this type to be written in the form 'C<int>' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1096) + + + + + Type parameters must be placed directly adjacent to the type name, e.g. \"type C<'T>\", not type \"C <'T>\" + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1094) + + + + + Type arguments must be placed directly adjacent to the type name, e.g. \"C<'T>\", not \"C <'T>\" + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1095) + + + + + No matching 'in' found for this 'let' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:452) + + + + + No #endif found for #if or #else + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:397) + + + + + No '=' symbol should follow a 'namespace' declaration + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:484) + + + + + Files should begin with either a namespace or module declaration, e.g. 'namespace SomeNamespace.SubNamespace' or 'module SomeNamespace.SomeModule', but not both. To define a module within a namespace use 'module SomeModule = ...' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:408) + + + + + Multiple accessibilities given for property getter or setter + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:431) + + + + + The syntax '(typ,...,typ) ident' is not used in F# code. Consider using 'ident<typ,...,typ>' instead + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:477) + + + + + A module name must be a simple name, not a path + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:415) + + + + + A module abbreviation must be a simple name, not a path + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:409) + + + + + Missing qualification after '.' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:465) + + + + + Missing function body + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:473) + + + + + Mismatched quotation, beginning with '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:467) + + + + + Mismatched quotation operator name, beginning with '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:482) + + + + + This member is not permitted in an object implementation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:472) + + + + + The declaration form 'let ... and ...' for non-recursive bindings is not used in F# code. Consider using a sequence of 'let' bindings + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:448) + + + + + Invalid property getter or setter + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1091) + + + + + Invalid operator definition. Prefix operator definitions must use a valid prefix operator name. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1116) + + + + + Invalid prefix operator + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1115) + + + + + Invalid declaration syntax + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:427) + + + + + Interfaces always have the same visibility as the enclosing type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:433) + + + + + An integer for loop must use a simple identifier + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:401) + + + + + Accessibility modifiers are not permitted on inline assembly code types + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:442) + + + + + 'inherit' declarations cannot have 'as' bindings. To access members of the base class when overriding a method, the syntax 'base.SomeMember' may be used; 'base' is a keyword. Remove this 'as' binding. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:437) + + + + + An indexer property must be given at least one argument + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1092) + + + + + Ignoring visibility attribute on module abbreviation. Module abbreviations are always private. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:412) + + + + + Ignoring accessibility attribute on module abbreviation. Module abbreviations are always private. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:411) + + + + + Ignoring attributes on module abbreviation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:410) + + + + + Identifier expected + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:460) + + + + + A getter property is expected to be a function, e.g. 'get() = ...' or 'get(index) = ...' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:430) + + + + + A getter property may have at most one argument group + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1089) + + + + + 'get', 'set' or 'get,set' required + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:424) + + + + + 'get' and/or 'set' required + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:428) + + + + + Field bindings must have the form 'id = expr;' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:471) + + + + + Block following this '%s' is unfinished. Expect an expression. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:454) + + + + + Error in the return expression for this 'let'. Possible incorrect indentation. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:453) + + + + + Error in 'function' block + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:474) + + + + + '=' expected + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:461) + + + + + End of file in verbatim string embedded in comment begun at or before here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:394) + + + + + End of file in verbatim string begun at or before here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:391) + + + + + End of file in string embedded in comment begun at or before here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:393) + + + + + End of file in string begun at or before here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:390) + + + + + End of file in IF-OCAML section begun at or before here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:395) + + + + + End of file in #if section begun at or after here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:389) + + + + + End of file in directive begun at or before here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:396) + + + + + End of file in comment begun at or before here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:392) + + + + + Accessibility modifiers are not permitted in this position for enum types + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:440) + + + + + Accessibility modifiers are not permitted on enumeration fields + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:445) + + + + + A type definition requires one or more members or other declarations. If you intend to define an empty class, struct or interface, then use 'type ... = class end', 'interface end' or 'struct end'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:422) + + + + + 'done' expected after this expression + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:457) + + + + + 'do' expected after this expression + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:458) + + + + + Accessibility modifiers are not permitted on 'do' bindings + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:388) + + + + + Consider using a separate record type instead + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:446) + + + + + Augmentations are not permitted on delegate type moduleDefns + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:420) + + + + + Attributes should be placed before 'val' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:417) + + + + + Attributes are not permitted on 'inherit' declarations + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:435) + + + + + Attributes are not allowed here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:438) + + + + + Attributes have been ignored in this construct + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:398) + + + + + Attributes are not permitted on interface implementations + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:418) + + + + + 'assert' may no longer be used as a first class value. Use 'assert <expr>' instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:456) + + + + + The use of '->' in sequence and computation expressions is limited to the form 'for pat in expr -> expr'. Use the syntax 'for ... in ... do ... yield...' to generate elements in more complex sequence expressions. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:462) + + + + + All enum fields must be given values + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:441) + + + + + Active pattern case identifiers must begin with an uppercase letter + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:483) + + + + + Accessibility modifiers are not allowed on this member. Abstract slots always have the same visibility as the enclosing type. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:434) + + + + + Write the xmldoc of the assembly to the given file + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:876) + + + + + Specify a Win32 resource file (.res) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:884) + + + + + Specify a Win32 manifest file + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:885) + + + + + Report all warnings as errors + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:894) + + + + + Report specific warnings as errors + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:895) + + + + + Set a warning level (0-4) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:896) + + + + + Output messages in UTF-8 encoding + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:904) + + + + + Unrecognized target '%s', expected 'exe', 'winexe', 'library' or 'module' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:913) + + + + + Unrecognized debug type '%s', expected 'pdbonly' or 'full' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:914) + + + + + Unrecognized platform '%s', valid values are 'x86', 'x64', 'Itanium', and 'anycpu' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:928) + + + + + Unknown --test argument: '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:927) + + + + + Enable or disable tailcalls + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:892) + + + + + Specify a strong name key file + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:877) + + + + + Specify a strong name key container + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:878) + + + + + Statically link the given assembly and all referenced DLLs that depend on this assembly. Use an assembly name e.g. mylib, not a DLL name. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:910) + + + + + Statically link the F# library and all referenced DLLs that depend on it into the assembly being generated + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:909) + + + + + Resolve assembly references using directory-based mono rules rather than MSBuild resolution (Default=false except when running fsc.exe under mono) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:912) + + + + + Print the inferred interface of the assembly to a file + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:882) + + + + + Short form of '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:916) + + + + + Embed the specified managed resource + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:887) + + + + + Reference an assembly (Short form: -r) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:883) + + + + + Problem with codepage '%d': %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:868) + + + + + Limit which platforms this code can run on: x86, Itanium, x64 or anycpu. The default is anycpu. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:879) + + + + + Name the output debug file + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:911) + + + + + Enable optimizations (Short form: -O) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:891) + + + + + Do not include the default Win32 manifest + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:886) + + + + + Disable specific warning messages + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:897) + + + + + Suppress compiler copyright message + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:901) + + + + + Do not reference the default CLI assemblies by default + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:908) + + + + + Only include optimization information essential for implementing inlined constructs. Inhibits cross-module inlining but improves binary compatibility. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:880) + + + + + Don't add a resource to the generated assembly containing F#-specific metadata + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:881) + + + + + Name of the output file (Short form: -o) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:870) + + + + + Ignore ML compatibility warnings + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:900) + + + + + Link the specified resource to this assembly where the resinfo format is <file>[,<string name>[,public|private]] + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:888) + + + + + Specify a directory for the include path which is used to resolve source files and assemblies (Short form: -I) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:906) + + + + + Invalid warning level '%d' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:915) + + + + + The command-line option '%s' is for internal use only + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:929) + + + + + - RESOURCES - + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:921) + + + + + - OUTPUT FILES - + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:919) + + + + + - MISCELLANEOUS - + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:924) + + + + + - LANGUAGE - + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:925) + + + + + - INPUT FILES - + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:920) + + + + + - ERRORS AND WARNINGS - + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:926) + + + + + - CODE GENERATION - + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:922) + + + + + - ADVANCED - + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:923) + + + + + Display this usage message (Short form: -?) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:902) + + + + + Output messages with fully qualified paths + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:905) + + + + + Delay-sign the assembly using only the public portion of the strong name key + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:875) + + + + + Define conditional compilation symbols (Short form: -d) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:899) + + + + + Emit debug information (Short form: -g) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:889) + + + + + Specify debugging type: full, pdbonly. ('full' is the default and enables attaching a debugger to a running program). + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:890) + + + + + The command-line option '%s' has been deprecated + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:930) + + + + + The command-line option '%s' has been deprecated. HTML document generation is now part of the F# Power Pack, via the tool FsHtmlDoc.exe. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:932) + + + + + The command-line option '%s' has been deprecated. Use '%s' instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:931) + + + + + Enable or disable cross-module optimizations + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:893) + + + + + Copyright (c) Microsoft Corporation. All Rights Reserved. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:869) + + + + + Specify the codepage used to read source files + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:903) + + + + + Use to override where the compiler looks for mscorlib.dll and framework components + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:918) + + + + + The command-line option '--cliroot' has been deprecated. Use an explicit reference to a specific copy of mscorlib.dll instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:917) + + + + + Generate overflow checks + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:898) + + + + + Build a Windows executable + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:872) + + + + + Build a module that can be added to another assembly + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:874) + + + + + Build a library (Short form: -a) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:873) + + + + + Build a console executable + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:871) + + + + + Base address for the library to be built + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:907) + + + + + A value marked as 'inline' has an unexpected value + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1007) + + + + + A value marked as 'inline' could not be inlined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1008) + + + + + The value '%s' was marked inline but was not bound in the optimization environment + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1005) + + + + + The value '%s' was marked inline but its implementation makes use of an internal or private function which is not sufficiently accessible + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1004) + + + + + Recursive ValValue %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1010) + + + + + Local value %s not found during optimization + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1006) + + + + + Failed to inline the value '%s' marked 'inline', perhaps because a recursive value was marked 'inline' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1009) + + + + + Unexpected empty long identifier + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1025) + + + + + Multiple types exist called '%s', taking different numbers of generic parameters. Provide a type instantiation to disambiguate the type resolution, e.g. '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1021) + + + + + The instantiation of the generic type '%s' is missing and can't be inferred from the arguments or return type of this member. Consider providing a type instantiation when accessing this type, e.g. '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1022) + + + + + The type '%s' does not contain a field '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1026) + + + + + No constructors are available for the type '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1029) + + + + + This is not a constructor or literal, or a constructor is being used incorrectly + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1024) + + + + + Invalid module/expression/type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1020) + + + + + Invalid field label + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1027) + + + + + Invalid expression '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1028) + + + + + 'global' may only be used as the first name in a qualified path + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1023) + + + + + No Invoke methods found for delegate type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:975) + + + + + More than one Invoke method found for delegate type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:976) + + + + + Could not determine highest installed .NET framework version from Registry keys, using version 2.0 + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1124) + + + + + This construct is for ML compatibility. %s. You can disable this warning by using '--mlcompatibility' or '--nowarn:62'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1111) + + + + + Infix operator member '%s' has %d initial argument(s). Expected a tuple of 2 arguments, e.g. static member (+) (x,y) = ... + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1075) + + + + + Infix operator member '%s' has no arguments. Expected a tuple of 2 arguments, e.g. static member (+) (x,y) = ... + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1074) + + + + + Infix operator member '%s' has extra curried arguments. Expected a tuple of 2 arguments, e.g. static member (+) (x,y) = ... + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1076) + + + + + Identifiers containing '@' are reserved for use in F# code generation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:986) + + + + + The identifier '%s' is reserved for future use by F# + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:987) + + + + + Possible incorrect indentation: this token is offside of context started at position %s. Try indenting this token further or using standard formatting conventions. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1015) + + + + + The '|' tokens separating rules of this pattern match are misaligned by one column. Consider realigning your code or using further indentation. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1016) + + + + + The indentation of this 'in' token is incorrect with respect to the corresponding 'let' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1014) + + + + + Syntax error. Wrong nested #endif, unexpected tokens before it. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1072) + + + + + Unexpected character '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1041) + + + + + This token is reserved for future use + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1062) + + + + + This Unicode encoding is only valid in string literals + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1061) + + + + + TABs are not allowed in F# code unless the #indent \"off\" option is used + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1063) + + + + + This number is outside the allowable range for 32-bit unsigned integers + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1050) + + + + + This number is outside the allowable range for 32-bit signed integers + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1049) + + + + + This number is outside the allowable range for 64-bit unsigned integers + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1052) + + + + + This number is outside the allowable range for 64-bit signed integers + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1051) + + + + + This number is outside the allowable range for 16-bit unsigned integers + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1048) + + + + + This number is outside the allowable range for 16-bit signed integers + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1047) + + + + + This number is outside the allowable range for unsigned native integers + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1054) + + + + + This number is outside the allowable range for signed native integers + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1053) + + + + + This number is outside the allowable range for this integer type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1038) + + + + + This number is outside the allowable range for 8-bit unsigned integers + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1046) + + + + + This number is outside the allowable range for hexadecimal 8-bit signed integers + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1045) + + + + + This number is outside the allowable range for 8-bit signed integers + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1044) + + + + + This number is outside the allowable range for 32-bit floats + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1057) + + + + + This number is outside the allowable range for decimal literals + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1056) + + + + + Character sequences beginning with '?' are no longer permitted as operator names + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1040) + + + + + This is not a valid numeric literal. Sample formats include 4, 0x4, 0b0100, 4L, 4UL, 4u, 4s, 4us, 4y, 4uy, 4.0, 4.0f, 4I. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1058) + + + + + Invalid line number: '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1064) + + + + + Invalid floating point number + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1055) + + + + + This is not a valid character literal + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1060) + + + + + This is not a valid byte literal + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1059) + + + + + Consider using a file with extension '.ml' or '.mli' instead + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1118) + + + + + Identifiers followed by '%s' are reserved for future use + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1043) + + + + + #if directive should be immediately followed by an identifier + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1071) + + + + + #if directive must appear as the first non-whitespace character on a line + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1065) + + + + + #endif has no matching #if + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1069) + + + + + #endif required for #else + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1067) + + + + + #endif directive must appear as the first non-whitespace character on a line + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1070) + + + + + #else has no matching #if + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1066) + + + + + #else directive must appear as the first non-whitespace character on a line + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1068) + + + + + Expected single line comment or end of line + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1073) + + + + + '%s' is not permitted as a character in operator names and is reserved for future use + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1039) + + + + + This byte array literal contains characters that do not encode as a single byte + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1042) + + + + + The type '%s' is required here and is unavailable. You must add a reference to assembly '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:996) + + + + + A reference to the type '%s' in assembly '%s' was found, but the type could not be found in that assembly + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:997) + + + + + A reference to the DLL %s is required by assembly %s. The imported type %s is located in the first assembly and could not be resolved. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:999) + + + + + Internal error or badly formed metadata: not enough type parameters were in scope while importing + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:998) + + + + + An imported assembly uses the type '%s' but that type is not public + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1000) + + + + + PDB files cannot be generated when running on Mono + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1034) + + + + + Unexpected error creating debug information file '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1033) + + + + + Values marked with 'LiteralAttribute' must currently be simple integer, character, Boolean, string or floating point constants + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:849) + + + + + Values marked with 'LiteralAttribute' cannot be mutable + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:848) + + + + + Compiler error: unexpected unrealized value + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:857) + + + + + Unexpected GetSet annotation on a property + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:860) + + + + + Undefined value '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:842) + + + + + This type cannot be used for a literal field + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:859) + + + + + The StructLayout attribute could not be decoded + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:862) + + + + + GenSetStorage: %s was represented as a static method but was not an appropriate lambda expression + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:855) + + + + + The signature for this external function contains type parameters. Constrain the argument and return types to indicate the types of the corresponding C function. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:852) + + + + + Reflected definitions cannot contain uses of the prefix splice operator '%%' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:864) + + + + + Mutable variables cannot escape their method + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:856) + + + + + The MarshalAs attribute could not be decoded + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:851) + + + + + Main module of program is empty: nothing will happen when it is run + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:858) + + + + + Literal fields cannot be set + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:854) + + + + + Label %s not found + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:843) + + + + + Incorrect number of type arguments to local call + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:844) + + + + + The FieldOffset attribute could not be decoded + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:861) + + + + + The FieldOffset attribute can only be placed on members of types marked with the StructLayout(LayoutKind.Explicit) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1121) + + + + + The type '%s' has been marked as having an Explicit layout, but the field '%s' has not been marked with the 'FieldOffset' attribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1113) + + + + + Dynamic invocation of %s is not supported + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:845) + + + + + The DllImport attribute could not be decoded + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:853) + + + + + The DefaultAugmentation attribute could not be decoded + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:863) + + + + + Custom marshallers cannot be specified in F# code. Consider using a C# helper function. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:850) + + + + + This operation involves taking the address of a value '%s' represented using a local variable or other special representation. This is invalid. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:847) + + + + + Taking the address of a literal field is invalid + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:846) + + + + + This file was automatically generated by a call to Goto Definition + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:936) + + + + + If set to true, then all error messages will just return the filled 'holes' delimited by ',,,'s - this is for language-neutral testing (e.g. localization-invariant baselines). + + + + + Prefix flag (' ' or '+') set twice + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:237) + + + + + Precision missing after the '.' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:242) + + + + + Positional specifiers are not permitted in format strings + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:234) + + + + + Missing format specifier + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:235) + + + + + The 'l' or 'L' in this format specifier is unnecessary except for ML compatibility. In F# code you can use %%d, %%x, %%o or %%u instead, which are overloaded to work with all basic integer types. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:245) + + + + + The # formatting modifier is invalid in F# + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:238) + + + + + The 'h' or 'H' in this format specifier is unnecessary. You can use %%d, %%x, %%o or %%u instead, which are overloaded to work with all basic integer types.. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:246) + + + + + '%s' format does not support precision + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:243) + + + + + '%s' flag set twice + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:236) + + + + + '%s' format does not support '0' flag + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:241) + + + + + '%s' does not support prefix '%s' flag + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:247) + + + + + Bad width in format specifier + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:240) + + + + + Bad precision in format specifier + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:239) + + + + + Bad format specifier: '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:248) + + + + + Bad format specifier (after l or L): Expected ld,li,lo,lu,lx or lX. These format specifiers support ML compatibility. In F# code you can use %%d, %%x, %%o or %%u instead, which are overloaded to work with all basic integer types. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:244) + + + + + The record, struct or class field '%s' is not accessible from this code location + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:972) + + + + + This construct is experimental + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:974) + + + + + The event '%s' has a non-standard type. If this event is declared in another CLI language, you may need to access this event using the explicit %s and %s methods for the event. If this event is declared in F#, make the type of the event an instantiation of either 'IDelegateEvent<_>' or 'IEvent<_,_>'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:967) + + + + + System.Environment.Exit did not exit + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:252) + + + + + The treatment of this operator is now handled directly by the F# compiler and its meaning cannot be redefined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:253) + + + + + Delegates are not allowed to have curried signatures + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:977) + + + + + This type parameter cannot be instantiated to 'Nullable'. This is a restriction imposed in order to ensure the meaning of 'null' in some CLI languages is not confusing when used in conjunction with 'Nullable' values. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:349) + + + + + The type '%s' is not compatible with any of the types %s, arising from the use of a printf-style format string + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:352) + + + + + The type '%s' is not a CLI enum type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:346) + + + + + The type '%s' is not a CLI delegate type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:348) + + + + + Type instantiation length mismatch + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:356) + + + + + Type inference problem too complicated (maximum iteration depth reached). Consider adding further type annotations. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:330) + + + + + The type '%s' has a non-standard delegate type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:347) + + + + + The type '%s' does not support any operators named '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:334) + + + + + The type '%s' does not support the 'equality' constraint because it is a record, union or struct with one or more structural element types which do not support the 'equality' constraint. Either avoid the use of equality with this type, or add the 'StructuralEquality' attribute to the type to determine which field type does not support equality + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:345) + + + + + The type '%s' does not support the 'equality' constraint because it is a function type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:344) + + + + + The type '%s' does not support the 'equality' constraint because it has the 'NoEquality' attribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:343) + + + + + The type '%s' does not support a conversion to the type '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:335) + + + + + The type '%s' does not support the 'comparison' constraint because it is a record, union or struct with one or more structural element types which do not support the 'comparison' constraint. Either avoid the use of comparison with this type, or add the 'StructuralComparison' attribute to the type to determine which field type does not support comparison + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:342) + + + + + The type '%s' does not support the 'comparison' constraint. For example, it does not support the 'System.IComparable' interface + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:341) + + + + + The type '%s' does not support the 'comparison' constraint because it has the 'NoComparison' attribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:340) + + + + + The type '%s' does not have 'null' as a proper value + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:339) + + + + + The declared type parameter '%s' cannot be used here since the type parameter cannot be resolved at compile time + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:328) + + + + + The constraints 'struct' and 'not struct' are inconsistent + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:338) + + + + + The required signature is %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:368) + + + + + Optional arguments not permitted here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:357) + + + + + No overloads match for method '%s'. The available overloads are shown below (or in the Error List window). + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:383) + + + + + No %s member or object constructor named '%s' takes %d arguments. The named argument '%s' doesn't correspond to any argument or settable return property for any overload. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:381) + + + + + No %s member or object constructor named '%s' takes %d arguments. Note the call to this member also provides %d named arguments. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:380) + + + + + No %s member or object constructor named '%s' takes %d arguments + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:379) + + + + + Method or object constructor '%s' not found + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:382) + + + + + A unique overload for method '%s' could not be determined based on type information prior to this program point. The available overloads are shown below (or in the Error List window). A type annotation may be needed. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:384) + + + + + %s is not an instance method + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:366) + + + + + %s is not a static method + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:365) + + + + + The type '%s' has a method '%s' (full name '%s'), but the method is static + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:336) + + + + + The type '%s' has a method '%s' (full name '%s'), but the method is not static + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:337) + + + + + This method expects a CLI 'params' parameter in this position. 'params' is a way of passing a variable number of arguments to a method in languages such as C#. Consider passing an array for this argument + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:362) + + + + + The member or object constructor '%s' takes %d type argument(s) but is here given %d. The required signature is '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:375) + + + + + The member or object constructor '%s' requires %d argument(s) but is here given %d unnamed and %d named argument(s). The required signature is '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:373) + + + + + The member or object constructor '%s' takes %d argument(s) but is here given %d. The required signature is '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:374) + + + + + The member or object constructor '%s' requires %d additional argument(s). The required signature is '%s'. Some names for missing arguments are %s. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:372) + + + + + The member or object constructor '%s' requires %d argument(s). The required signature is '%s'. Some names for missing arguments are %s. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:371) + + + + + The member or object constructor '%s' requires %d additional argument(s). The required signature is '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:370) + + + + + The member or object constructor '%s' requires %d argument(s). The required signature is '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:369) + + + + + The member or object constructor '%s' does not take %d argument(s). An overload was found taking %d arguments. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:378) + + + + + The member or object constructor '%s' taking %d arguments are not accessible from this code location. All accessible versions of method '%s' take %d arguments. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:376) + + + + + %s is not a static member + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:358) + + + + + %s is not an instance member + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:359) + + + + + The member or object constructor '%s' is not %s. Private members may only be accessed from within the declaring type. Protected members may only be accessed from an extending type and cannot be accessed from inner lambda expressions. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:364) + + + + + The member or object constructor '%s' is not %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:363) + + + + + The member or object constructor '%s' has no argument or settable return property '%s'. %s. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:367) + + + + + This indexer expects %d arguments but is here given %d + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:332) + + + + + Incorrect generic instantiation. No %s member named '%s' takes %d generic arguments. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:377) + + + + + A generic construct requires that the type '%s' is an unmanaged type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:351) + + + + + A generic construct requires that the type '%s' is a CLI or F# struct type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:350) + + + + + A generic construct requires that the type '%s' have reference semantics, but it does not, i.e. it is a struct + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:353) + + + + + A generic construct requires that the type '%s' have a public default constructor + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:355) + + + + + A generic construct requires that the type '%s' be non-abstract + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:354) + + + + + Expected arguments to an instance member + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:331) + + + + + Expecting a type supporting the operator '%s' but given a function type. You may be missing an argument to a function. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:333) + + + + + This code is less generic than indicated by its annotations. A unit-of-measure specified using '_' has been determined to be '1', i.e. dimensionless. Consider making the code generic, or removing the use of '_'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:329) + + + + + The argument types don't match + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:361) + + + + + Argument length mismatch + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:360) + + + + + Quotations cannot contain expressions that set union case fields + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:315) + + + + + Quotations cannot contain expressions that set fields in exception values + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:316) + + + + + Quotations cannot contain expressions that require byref pointers + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:317) + + + + + Quotations cannot contain expressions that fetch union case indexes + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:314) + + + + + Quotations cannot contain this kind of type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:322) + + + + + Quotations cannot contain this kind of pattern match + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:320) + + + + + Quotations cannot contain this kind of constant + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:319) + + + + + Quotations cannot contain expressions that fetch static fields + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:311) + + + + + Quotations cannot contain object expressions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:309) + + + + + Quotations cannot contain literal byte arrays + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:323) + + + + + Quotations cannot contain inline assembly code or pattern matching on arrays + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:312) + + + + + Quotations cannot contain function declarations that are inferred or declared to be generic. Consider adding some type constraints to make this a valid quoted expression. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:308) + + + + + Quotations cannot contain uses of generic expressions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:307) + + + + + Quotations cannot contain descending for loops + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:313) + + + + + Quotations cannot contain array pattern matching + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:321) + + + + + Quotations cannot contain expressions that take the address of a field + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:310) + + + + + Quotations cannot contain expressions that make member constraint calls, or uses of operators that implicitly resolve to a member constraint call + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:318) + + + + + Inner generic functions are not permitted in quoted expressions. Consider adding some type constraints until this function is no longer generic. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:324) + + + + + The variable '%s' is bound in a quotation but is used as part of a spliced expression. This is not permitted since it may escape its scope. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:306) + + + + + The variable '%s' is used in an invalid way + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:261) + + + + + The type of a field using the 'DefaultValue' attribute must admit default initialization, i.e. have 'null' as a proper value or be a struct type whose fields all admit default initialization. You can use 'DefaultValue(false)' to disable this check + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:301) + + + + + The value '%s' is unused + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1087) + + + + + The recursive object reference '%s' is unused. The presence of a recursive object reference adds runtime initialization checks to members in this and derived types. Consider removing this recursive object reference. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1088) + + + + + default augmentation of the union case + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:286) + + + + + compiled form of the union case + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:285) + + + + + The type '%s' is less accessible than the value, member or type '%s' it is used in + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:262) + + + + + 'System.Void' can only be used as 'typeof<System.Void>' in F# + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:263) + + + + + Expression-splicing operators may only be used within quotations + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:266) + + + + + A method return type would contain byrefs which is not permitted + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:278) + + + + + [<ReflectedDefinition>] terms cannot contain uses of the prefix splice operator '%%' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:283) + + + + + A protected member is called or 'base' is being used. This is only allowed in the direct implementation of members since they could escape their object scope. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:257) + + + + + Name clash. The property '%s' has the same name as a method in this type. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:287) + + + + + The property '%s' has the same name as another property in this type, but one takes indexer arguments and the other does not. You may be missing an indexer argument to one of your properties. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:289) + + + + + Object constructors cannot directly use try/with and try/finally prior to the initialization of the object. This includes constructs such as 'for x in ...' that may elaborate to uses of these constructs. This is a limitation imposed by Common IL. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:272) + + + + + First-class uses of the expression-splicing operator are not permitted + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:267) + + + + + First-class uses of the 'reraise' function is not permitted + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:269) + + + + + First-class uses of the address-of operators are not permitted + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:268) + + + + + The type abbreviation contains byrefs. This is not permitted by F#. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:302) + + + + + The byref typed value '%s' cannot be used at this point + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:270) + + + + + A byref typed value would be stored here. Top-level let-bound byref values are not permitted. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:282) + + + + + The address of the static field '%s' cannot be used at this point + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:274) + + + + + The address of the variable '%s' cannot be used at this point + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:273) + + + + + The address of an array element cannot be used at this point + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:276) + + + + + The address of the field '%s' cannot be used at this point + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:275) + + + + + The mutable variable '%s' is used in an invalid way. Mutable variables cannot be captured by closures. Consider eliminating this use of mutation or using a heap-allocated mutable reference cell via 'ref' and '!'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:259) + + + + + This type implements or inherits the same interface at different generic instantiations '%s' and '%s'. This is not permitted in this version of F#. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:300) + + + + + The member '%s' is used in an invalid way. A use of '%s' has been inferred prior to its definition at or near '%s'. This is an invalid forward reference. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:281) + + + + + 'base' values may only be used to make direct calls to the base implementations of overridden members + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:271) + + + + + Invalid custom attribute value (not a constant or literal) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:279) + + + + + The property '%s' has a getter and a setter that do not match. If one is abstract then the other must be as well. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:288) + + + + + The type of a first-class function cannot contain byrefs + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:277) + + + + + A type instantiation involves a byref type. This is not permitted by the rules of Common IL. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:264) + + + + + Calls to 'reraise' may only occur directly in a handler of a try-with + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:265) + + + + + A function labeled with the 'EntryPointAttribute' attribute must be the last declaration in the last file in the compilation sequence, and can only be used when compiling to a .exe + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:284) + + + + + Duplicate property. The property '%s' has the same name and signature as another property in this type once tuples, functions and/or units of measure are erased. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:297) + + + + + Duplicate property. The property '%s' has the same name and signature as another property in this type. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:296) + + + + + Duplicate method. The method '%s' has the same name and signature as another method in this type once tuples, functions and/or units of measure are erased. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:293) + + + + + Duplicate method. The abstract method '%s' has the same name and signature as an abstract method in an inherited type once tuples, functions and/or units of measure are erased. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:299) + + + + + Duplicate method. The abstract method '%s' has the same name and signature as an abstract method in an inherited type. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:298) + + + + + The method '%s' has curried arguments but has the same name as another method in this type. Methods with curried arguments cannot be overloaded. Consider using a method taking tupled arguments. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:294) + + + + + Duplicate method. The method '%s' has the same name and signature as another method in this type. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:292) + + + + + Methods with curried arguments cannot declare 'out', 'ParamArray', 'optional' or 'byref' arguments + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:295) + + + + + A type would store a byref typed value. This is not permitted by Common IL. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:290) + + + + + The byref-typed variable '%s' is used in an invalid way. Byrefs cannot be captured by closures or passed to inner functions. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:258) + + + + + The 'base' keyword is used in an invalid way. Base calls cannot be used in closures. Consider using a private member to make base calls. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:260) + + + + + The attribute type '%s' has 'AllowMultiple=false'. Multiple instances of this attribute cannot be attached to a single language element. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:280) + + + + + Unrecognized option: '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:60) + + + + + ParseInput: unknown file suffix for '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:41) + + + + + The non-generic type '%s' does not expect any type arguments, but here is given %d type argument(s) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:17) + + + + + The signature file '%s' does not have a corresponding implementation file. If an implementation file exists then check the 'module' and 'namespace' declarations in the signature and implementation files match. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:57) + + + + + A signature for the file or module '%s' has already been specified + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:54) + + + + + The search directory '%s' could not be found + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:27) + + + + + The file '%s' is a CLI 1.x version of mscorlib. F# requires CLI version 2.0 or greater. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:32) + + + + + Microsoft (R) F# 2.0 Compiler build %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:21) + + + + + Problem with filename '%s': %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:22) + + + + + The '--pdb' option requires the '--debug' option to be used + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:25) + + + + + Option requires parameter: %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:42) + + + + + No inputs specified + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:23) + + + + + This file contains multiple declarations of the form 'module SomeNamespace.SomeModule'. Only one declaration of this form is permitted in a file. Change your file to use an initial namespace declaration and/or use 'module ModuleName = ...' to define your modules. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:40) + + + + + Multiple references to '%s.dll' are not permitted + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:31) + + + + + Files in libraries or multiple-file applications must begin with a namespace or module declaration, e.g. 'namespace SomeNamespace.SubNamespace' or 'module SomeNamespace.SomeModule' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:39) + + + + + The referenced or default base CLI library 'mscorlib' is binary-incompatible with the referenced library '%s'. Consider recompiling the library or making an explicit reference to a version of this library that matches the CLI version you are using. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:34) + + + + + The referenced or default base CLI library 'mscorlib' is binary-incompatible with the referenced F# core library '%s'. Consider recompiling the library or making an explicit reference to a version of this library that matches the CLI version you are using. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:36) + + + + + The output name extension doesn't match the options used. If '-a' or '--target:library' is used the output file name must end with '.dll', if '--target:module' is used the output extension must be '.netmodule', otherwise '.exe'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:24) + + + + + Invalid warning number '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:18) + + + + + Invalid version string '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:19) + + + + + Invalid version file '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:20) + + + + + The file extension of '%s' is not recognized. Source files must have extension .fs, .fsi, .fsx, .fsscript, .ml or .mli. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:44) + + + + + The search directory '%s' is invalid + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:26) + + + + + Unrecognized privacy setting '%s' for managed resource, valid options are 'public' and 'private' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:30) + + + + + Invalid module or namespace name + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:61) + + + + + Invalid directive. Expected '#time', '#time \"on\"' or '#time \"off\"'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:52) + + + + + Invalid directive. Expected '#r \"<file-or-assembly>\"'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:50) + + + + + Invalid directive. Expected '#load \"<file>\" ... \"<file>\"'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:51) + + + + + Invalid directive. Expected '#I \"<path>\"'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:49) + + + + + '%s' is not a valid filename + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:28) + + + + + '%s' is not a valid assembly name + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:29) + + + + + The declarations in this file will be placed in an implicit module '%s' based on the file name '%s'. However this is not a valid F# identifier, so the contents will not be accessible from other files. Consider renaming the file or adding a 'module' or 'namespace' declaration at the top of the file. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:38) + + + + + An implementation of file or module '%s' has already been given. Compilation order is significant in F# because of type inference. You may need to adjust the order of your files to place the signature file before the implementation. In Visual Studio files are type-checked in the order they appear in the project file, which can be edited manually or adjusted using the solution explorer. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:55) + + + + + An implementation of the file or module '%s' has already been given + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:56) + + + + + When mscorlib.dll or FSharp.Core.dll is explicitly referenced the %s option must also be passed + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:62) + + + + + FSharp.Core.sigdata not found alongside FSharp.Core + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:64) + + + + + File '%s' not found alongside FSharp.Core + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:66) + + + + + Error opening binary file '%s': %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:47) + + + + + Directives inside modules are ignored + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:53) + + + + + The F#-compiled DLL '%s' needs to be recompiled to be used with this version of F# + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:48) + + + + + Did not expect to find sigdata resource in FSharp.Core.dll + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:63) + + + + + Did not expect to find optdata resource in FSharp.Core.dll + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:65) + + + + + Could not resolve assembly '%s' required by '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:46) + + + + + Could not resolve assembly '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:45) + + + + + Could not read version from mscorlib.dll + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:33) + + + + + Source file '%s' could not be found + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:43) + + + + + The file extensions '.ml' and '.mli' are for ML compatibility + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1117) + + + + + Unable to read assembly '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:35) + + + + + Assembly resolution failure at or near this location + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:37) + + + + + '%s' is not a valid integer argument + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:58) + + + + + '%s' is not a valid floating point argument + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:59) + + + + + A type cannot have both the 'ReferenceEquality' and 'StructuralEquality' or 'StructuralComparison' attributes + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:223) + + + + + The 'StructuralEquality' attribute must be used in conjunction with the 'NoComparison' or 'StructuralComparison' attributes + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:222) + + + + + The 'StructuralComparison' attribute must be used in conjunction with the 'StructuralEquality' attribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:221) + + + + + A type with attribute 'ReferenceEquality' cannot have an explicit implementation of 'Object.Equals(obj)', 'System.IEquatable<_>' or 'System.Collections.IStructuralEquatable' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:225) + + + + + Only record, union, exception and struct types may be augmented with the 'ReferenceEquality', 'StructuralEquality' and 'StructuralComparison' attributes + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:224) + + + + + The 'ReferenceEquality' attribute cannot be used on structs. Consider using the 'StructuralEquality' attribute instead, or implement an override for 'System.Object.Equals(obj)'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:218) + + + + + The 'NoEquality' attribute must be used in conjunction with the 'NoComparison' attribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:220) + + + + + A type with attribute 'NoEquality' should not usually have an explicit implementation of 'Object.Equals(obj)'. Disable this warning if this is intentional for interoperability purposes + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:228) + + + + + A type with attribute 'NoComparison' should not usually have an explicit implementation of 'System.IComparable', 'System.IComparable<_>' or 'System.Collections.IStructuralComparable'. Disable this warning if this is intentional for interoperability purposes + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:229) + + + + + This type uses an invalid mix of the attributes 'NoEquality', 'ReferenceEquality', 'StructuralEquality', 'NoComparison' and 'StructuralComparison' attributes + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:219) + + + + + A type with attribute 'CustomEquality' must have an explicit implementation of at least one of 'Object.Equals(obj)', 'System.IEquatable<_>' or 'System.Collections.IStructuralEquatable' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:226) + + + + + The 'CustomEquality' attribute must be used in conjunction with the 'NoComparison' or 'CustomComparison' attributes + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:230) + + + + + A type with attribute 'CustomComparison' must have an explicit implementation of at least one of 'System.IComparable' or 'System.Collections.IStructuralComparable' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:227) + + + + + Error while parsing embedded IL type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:212) + + + + + Error while parsing embedded IL + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:211) + + + + + Invalid expression on left of assignment + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:214) + + + + + This indexer notation has been removed from the F# language + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:213) + + + + + .NET Framework + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:960) + + + + + Global Assembly Cache + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:961) + + + + + Found by AssemblyFolders registry key + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:958) + + + + + Found by AssemblyFoldersEx registry key + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:959) + + + + + Active pattern '%s' is not a function + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1119) + + + + + Active pattern '%s' has a result type containing type variables that are not determined by the input. The common cause is a when a result case is not mentioned, e.g. 'let (|A|B|) (x:int) = A x'. This can be fixed with a type constraint, e.g. 'let (|A|B|) (x:int) : Choice<int,unit> = A x' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1120) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nOne is virtual and the other isn't + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:120) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe types differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:112) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nOne is static and the other isn't + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:119) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe compiled representation of this method is as a static member but the signature indicates its compiled representation is as an instance member + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:125) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe respective type parameter counts differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:111) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nOne is marked as an override and the other isn't + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:123) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nOne is a type function and the other is not. The signature requires explicit type parameters if they are present in the implementation. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:110) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nOne is a constructor/property and the other is not + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:124) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe names differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:104) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe literal constant values and/or attributes differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:109) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe compiled representation of this method is as an instance member, but the signature indicates its compiled representation is as a static member + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:126) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe inline flags differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:108) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe number of generic parameters in the signature and implementation differ (the signature declares %s but the implementation declares %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:115) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe generic parameters in the signature and implementation have different kinds. Perhaps there is a missing [<Measure>] attribute. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:116) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nOne is final and the other isn't + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:122) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nOne is an extension member and the other is not + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:113) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe CLI member names differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:118) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe display names differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:106) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe compiled names differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:105) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe mutability attributes differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:103) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nAn arity was not inferred for this value + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:114) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe arities in the signature and implementation differ. The signature specifies that '%s' is function definition or lambda expression accepting at least %s argument(s), but the implementation is a computed function value. To declare that a computed function value is a permitted implementation simply parenthesize its type in the signature, e.g.\n\tval %s: int -> (int -> int)\ninstead of\n\tval %s: int -> int -> int. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:117) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe accessibility specified in the signature is more than that specified in the implementation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:107) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nOne is abstract and the other isn't + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:121) + + + + + Call this method once to validate that all known resources are valid; throws if not + + + + + The module contains the constructor\n %s \nbut its signature specifies\n %s \nThe types of the fields differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:161) + + + + + The module contains the constructor\n %s \nbut its signature specifies\n %s \nThe names differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:159) + + + + + The module contains the constructor\n %s \nbut its signature specifies\n %s \nThe respective number of data fields differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:160) + + + + + The module contains the constructor\n %s \nbut its signature specifies\n %s \nthe accessibility specified in the signature is more than that specified in the implementation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:162) + + + + + Invalid recursive reference to an abstract slot + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:966) + + + + + The module contains the field\n %s \nbut its signature specifies\n %s \nThe types differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:168) + + + + + The module contains the field\n %s \nbut its signature specifies\n %s \nThe 'static' modifiers differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:165) + + + + + The module contains the field\n %s \nbut its signature specifies\n %s \nThe names differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:163) + + + + + The module contains the field\n %s \nbut its signature specifies\n %s \nThe 'mutable' modifiers differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:166) + + + + + The module contains the field\n %s \nbut its signature specifies\n %s \nThe 'literal' modifiers differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:167) + + + + + The module contains the field\n %s \nbut its signature specifies\n %s \nthe accessibility specified in the signature is more than that specified in the implementation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:164) + + + + + The exception definitions are not compatible because the exception abbreviations in the signature and implementation differ. The module contains the exception definition\n %s \nbut its signature specifies\n\t%s. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:187) + + + + + The exception definitions are not compatible because a CLI exception mapping is being hidden by a signature. The exception mapping must be visible to other modules. The module contains the exception definition\n %s \nbut its signature specifies\n\t%s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:184) + + + + + The exception definitions are not compatible because the order of the fields is different in the signature and implementation. The module contains the exception definition\n %s \nbut its signature specifies\n\t%s. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:191) + + + + + The exception definitions are not compatible because the field '%s' was required by the signature but was not specified by the implementation. The module contains the exception definition\n %s \nbut its signature specifies\n\t%s. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:189) + + + + + The exception definitions are not compatible because the field '%s' was present in the implementation but not in the signature. The module contains the exception definition\n %s \nbut its signature specifies\n\t%s. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:190) + + + + + The exception definitions are not compatible because the exception declarations differ. The module contains the exception definition\n %s \nbut its signature specifies\n\t%s. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:188) + + + + + The exception definitions are not compatible because the CLI representations differ. The module contains the exception definition\n %s \nbut its signature specifies\n\t%s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:185) + + + + + The exception definitions are not compatible because the exception abbreviation is being hidden by the signature. The abbreviation must be visible to other CLI languages. Consider making the abbreviation visible in the signature. The module contains the exception definition\n %s \nbut its signature specifies\n\t%s. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:186) + + + + + The %s definitions in the signature and implementation are not compatible because the types have different base types + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:139) + + + + + The %s definitions in the signature and implementation are not compatible because a type representation is being hidden by a signature + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:145) + + + + + The %s definitions in the signature and implementation are not compatible because the types are of different kinds + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:146) + + + + + The %s definitions in the signature and implementation are not compatible because the signature says this type may use nulls as an extra value but the implementation does not + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:134) + + + + + The %s definitions in the signature and implementation are not compatible because the signature says this type may use nulls as a representation but the implementation does not + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:133) + + + + + The %s definitions in the signature and implementation are not compatible because the signature is an abstract class but the implementation is not. Consider adding the [<AbstractClass>] attribute to the implementation. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:138) + + + + + The %s definitions in the signature and implementation are not compatible because the signature defines the %s '%s' but the implementation does not (or does, but not in the same order) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:141) + + + + + The %s definitions in the signature and implementation are not compatible because the signature declares a %s while the implementation declares a %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:155) + + + + + The %s definitions in the signature and implementation are not compatible because the signature has an abbreviation while the implementation does not + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:158) + + + + + The %s definitions in the signature and implementation are not compatible because the representations differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:148) + + + + + The %s definitions in the signature and implementation are not compatible because the respective type parameter counts differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:128) + + + + + The %s definitions in the signature and implementation are not compatible because the number of %ss differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:140) + + + + + The %s definitions in the signature and implementation are not compatible because the names differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:127) + + + + + The %s definitions in the signature and implementation are not compatible because the signature requires that the type supports the interface %s but the interface has not been implemented + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:130) + + + + + The %s definitions in the signature and implementation are not compatible because the implementation type is sealed but the signature implies it is not. Consider adding the [<Sealed>] attribute to the signature. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:135) + + + + + The %s definitions in the signature and implementation are not compatible because the implementation says this type may use nulls as an extra value but the signature does not + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:132) + + + + + The %s definitions in the signature and implementation are not compatible because the implementation says this type may use nulls as a representation but the signature does not + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:131) + + + + + The %s definitions in the signature and implementation are not compatible because the implementation type is not sealed but signature implies it is. Consider adding the [<Sealed>] attribute to the implementation. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:136) + + + + + The %s definitions in the signature and implementation are not compatible because the implementation is an abstract class but the signature is not. Consider adding the [<AbstractClass>] attribute to the signature. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:137) + + + + + The %s definitions in the signature and implementation are not compatible because the implementation defines a struct but the signature defines a type with a hidden representation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:143) + + + + + The %s definitions in the signature and implementation are not compatible because the implementation defines the %s '%s' but the signature does not (or does, but not in the same order) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:142) + + + + + The %s definitions in the signature and implementation are not compatible because the IL representations differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:147) + + + + + The %s definitions in the signature and implementation are not compatible because the field %s was present in the implementation but not in the signature + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:149) + + + + + The %s definitions in the signature and implementation are not compatible because the field %s was required by the signature but was not specified by the implementation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:151) + + + + + The %s definitions in the signature and implementation are not compatible because the order of the fields is different in the signature and implementation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:150) + + + + + The %s definitions in the signature and implementation are not compatible because the field %s was present in the implementation but not in the signature. Struct types must now reveal their fields in the signature for the type, though the fields may still be labelled 'private' or 'internal'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:152) + + + + + The %s definitions in the signature and implementation are not compatible because a CLI type representation is being hidden by a signature + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:144) + + + + + The %s definitions in the signature and implementation are not compatible because the accessibility specified in the signature is more than that specified in the implementation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:129) + + + + + The %s definitions in the signature and implementation are not compatible because the abstract member '%s' was present in the implementation but not in the signature + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:154) + + + + + The %s definitions in the signature and implementation are not compatible because the abstract member '%s' was required by the signature but was not specified by the implementation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:153) + + + + + The %s definitions in the signature and implementation are not compatible because the abbreviations differ: %s versus %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:156) + + + + + The %s definitions in the signature and implementation are not compatible because an abbreviation is being hidden by a signature. The abbreviation must be visible to other CLI languages. Consider making the abbreviation visible in the signature. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:157) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Convert string into Option string where null and String.Empty result in None + + + + + + + + + + + + + + Get the System.Reflection.Assembly object for the assembly + + + + + Holds the full qualified assembly name + + + + + Get the object representing the F# core library (FSharp.Core.dll) for the running program + + + + + A handle to the full specification of the contents of the module contained in this Assembly + + + + + A hint as to where does the code for the CCU live (e.g what was the tcConfig.implicitIncludeDir at compilation time for this DLL?) + + + + + Return the System.Reflection.Assembly object for the assembly + + + + + This is one way of starting the loading process off. + + + + + This is one way of starting the loading process off. Dependencies are automatically + resolved by calling System.Reflection.Assembly.Load. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Get the XML documentation signature for the entity + + + + + Indicates the type prefers the "tycon<a,b>" syntax for display etc. + + + + + Get the cases of a discriminated union + + + + + Get the declared accessibility of the representation, not taking signatures into account + + + + + Get the System.Type for the type + + Raises InvalidOperationException if the type is an abbreviation or has an assembly code representation. + + + + + Get the System.Reflection.Assembly for the type + + May raise an exception if an assembly load fails + + + + + Get the fields of the class, struct or enum + + + + + Get the fully qualified name of the type or module + + + + + + + + Get the namespace containing the type or module, if any + + + + + Properties, methods etc. with implementations, also values in a module + + + + + Get the name of the type or module, possibly with `n mangling + + + + + Indicates the entity is a struct or enum + + + + + Indicates the entity is union type + + + + + Indicates the entity is record type + + + + + Indicates the entity is an F# module definition + + + + + Indicates the entity is a measure definition + + + + + If true, then this is a reference to something in some .NET assembly from another .NET language + + + + + Indicates an F# exception declaration + + + + + Indicates the entity is a measure, type or exception abbreviation + + + + + Interface implementations - boolean indicates compiler-generated + + + + + Indicates that a module is compiled to a class with the given mangled name. The mangling is reversed during lookup + + + + + Indicates the type is implemented through a mapping to IL assembly code. THis is only + true for types in FSharp.Core.dll + + + + + Get the generic parameters, possibly including unit-of-measure parameters + + + + + Get the name of the type or module as displayed in F# code + + + + + Get the entity containing the type or module, if any + + + + + Get the declaration location for the type constructor + + + + + Get the compiled name of the type or module, possibly with `n mangling. This is identical to LogicalName + unless the CompiledName attribute is used. + + + + + Base type, if any + + + + + Get the declared attributes for the type + + + + + Get the declared accessibility of the type + + + + + + + + Return the FSharpEntity corresponding to a .NET type + + + + + Represents an F# type or module + + + + + + + + + + + Get the documentation for the type parameter. + + + + + Get the name of the generic parameter + + + + + Indicates if this is a statically resolved type variable + + + + + Indicates if this is a measure variable + + + + + Get the range of the generic parameter + + + + + Get the declared or inferred constraints for the type parameter + + + + + Get the declared attributes of the type parameter. + + + + + + + + + + + + + + + + + + + + + + + + + + Indicates a constraint that a type is an unmanaged type + + + + + Indicates a constraint that a type has a 'null' value + + + + + Indicates a constraint that a type is a simple choice between one of the given ground types. Used by printf format strings. + + + + + Indicates a constraint that a type has a parameterless constructor + + + + + Indicates a constraint that a type is a reference type + + + + + Indicates a constraint that a type is a non-Nullable value type + + + + + Indicates a constraint that a type has a member with the given signature + + + + + Indicates a constraint that a type supports F# generic equality + + + + + Indicates a constraint that a type is an enum with the given underlying + + + + + Indicates a constraint that a type is a delegate from the given tuple of args to the given return type + + + + + Indicates a default value for an inference type variable should it be netiher generalized nor solved + + + + + Indicates a constraint that a type supports F# generic comparison + + + + + Indicates a constraint that a type is a subtype of the given type + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Indictes the value is inlined but the code for the function still exists, e.g. to satisfy interfaces on objects, but that it is also always inlined + + + + + + + + + + + + + + + + + + + + XML documentation signature for the value. + + + + + Get the full type of the member or value when used as a first class value + + + + + + + + Get the reflection object for this member + + + + + Get the logical name of the member + + + + + Get the logical enclosing entity, which for an extension member is type being extended + + + + + Indicates if this is an F# type function + + + + + Indicates if this is a setter method for a property + + + + + Indicates if this is a mutable value + + + + + Indicates if this is a module or member value + + + + + Indicates if this is a member, including extension members? + + + + + Indicates if this is an instance member, when seen from F#? + + + + + Indicates if this is an implicit constructor? + + + + + Indicates if this is a getter method for a property + + + + + Indicates if this is an extension member? + + + + + Indicates if this is an abstract member? + + + + + Indicates if this is a compiler generated value + + + + + Indicates if this value or member is an F# active pattern + + + + + Get a result indicating if this is a must-inline value + + + + + Get the typars of the member or value + + + + + + + + Get the name as presented in F# error messages and documentation + + + + + Get the declaration location of the member or value + + + + + + + + Get the member name in compiled code + + + + + Custom attributes attached to the value. These contain references to other values (i.e. constructors in types). Mutable to fixup + these value references after copying a colelction of values. + + + + + How visible is this? + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Get the XML documentation signature for the field + + + + + Get the type of the field, w.r.t. the generic parameters of the enclosing type constructor + + + + + Get the attributes attached to generated property + + + + + Get the name of the field + + + + + Indicates a static field + + + + + Is the field declared in F#? + + + + + Indicates a compiler generated field, not visible to Intellisense or name resolution + + + + + Get the attributes attached to generated field + + + + + Get the declaration location of the field + + + + + Indicates the declared visibility of the field, not taking signatures into account + + + + + + + + + + + + + + Get the named entity for a type constructed using a named entity + + + + + Indicates the type is a tuple type. The GenericArguments property returns the elements of the tuple type. + + + + + Indicates the type is constructed using a named entity + + + + + Indicates the type is a variable type, whether declared, generalized or an inference type parameter + + + + + Indicates the type is a function type. The GenericArguments property returns the domain and range of the function type. + + + + + Get the index for a generic parameter type + + + + + Get the generic parameter data for a generic parameter type + + + + + Get the generic arguments for a tuple type, a function type or a type constructed using a named entity + + + + + + + + + + + + + + Get the XML documentation signature for the case + + + + + Get type constructed by the case. Normally exactly the type of the enclosing type, sometimes an abbreviation of it + + + + + Get the name of the case + + + + + Get the data carried by the case. + + + + + Get the range of the name of the case + + + + + Gete the name of the case in generated IL code + + + + + Get the attributes for the case, attached to the generated static method to make instances of the case + + + + + Indicates the declared visibility of the union constructor, not taking signatures into account + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Note this operation is O(n) anyway, so executing lastElements() here is OK + + + + + Note this operation is O(1), unless a push happens, which is rare + + + + + + + + + + + + + + + + + Iterable functional collection with O(1) append-1 time. Useful for data structures where elements get added at the + end but the collection must occadionally be iterated. Iteration is slower and may allocate because + a suffix of elements is stored in reverse order. + + The type doesn't support structural hashing or comparison. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + keyed first on namespace then on type name. The namespace is often a unique key for a given type map. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + The explicit offset in bytes when explicit layout is used. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Index table by name and arity. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + The type instantiation if the type is generic + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Calling conventions. These are used in method pointer types. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Global state: table of all assembly references keyed by AssemblyRefData + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + This is used to store event, property and field maps. + + Review: this is not such a great data structure. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Global State. All namespace splits + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + A little ugly, but the idea is that if a data structure does not + contain lazy values then we don't add laziness. So if the thing to map + is already evaluated then immediately apply the function. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + The assumptions that need to be fixed up + + + + + The data that uses a collection of CcuThunks internally + + + + + Like Fixup but loader may return None, in which case there is no fixup. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + This field holds either the function to run or a PPLazyFailure object recording the exception raised + from running the function. It is null if the thunk has been evaluated successfully. + + + + + This field holds the result of a successful computation. It's initial value is Unchecked.defaultof + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Treat a list of key-value pairs as a lookup collection. + This function returns true if two keys are the same according to the predicate + function passed in. + + + + + Treat a list of key-value pairs as a lookup collection. + This function looks up a value based on a match from the supplied + predicate function. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Try to chop "get_" or "set_" from a string + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Specifies the compiled representations of type and exception definitions. + Computed and cached by later phases (never computed type checking). Cached at + type and exception definitions. Not pickled. Cache an optional ILType object for + non-generic types + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + A representation of a method in an object expression. + Note: Methods associated with types are represented as val declarations + Note: We should probably use val_specs for object expressions, as then the treatment of members + in object expressions could be more unified with the treatment of members in types + + + + + + + + + + + + + + A call to a base method, e.g. 'base.OnPaint(args)' + + + + + A call to a constructor, e.g. 'new C() = new C(3)' + + + + + A call to a constructor, e.g. 'inherit C()' + + + + + A normal use of a value + + + + + Indicates a use of a value represents a call to a method that may require + a .NET 2.0 constrained call. A constrained call is only used for calls where + + + + + + + + let res = a in b;res + + + + + a ; b + + + + + + + + In C syntax this is: *localv_ptr = e + + + + + In C syntax this is: localv = e , note == *(&localv) = e == LGetAddr; LByrefSet + + + + + In C syntax this is: *localv_ptr + + + + + In C syntax this is: &localv + + + + + + + + Evaluate start once and end multiple times, loop up + + + + + Evaluate start and end once, loop down + + + + + Evaluate start and end once, loop up + + + + + + + + + + + + + + + + + + + + IL method calls + + + + + Operation nodes represnting C-style operations on byrefs and mutable vals (l-values) + + + + + Pseudo method calls. This is used for overloaded operations like op_Addition. + + + + + + + + Represents a "rethrow" operation. May not be rebound, or used outside of try-finally, expecting a unit argument + + + + + Conversion node, compiled via type-directed translation or to box/unbox + + + + + generate a ldflda on an 'a ref. + + + + + IL assembly code - type list are the types pushed on the stack + + + + + An operation representing a field-get from an F# tuple value. + + + + + An operation representing a field-set on an F# exception value. + + + + + An operation representing a field-get from an F# exception value. + + + + + An operation representing a field-get from a union value. THe value is not assumed to have been proven to be of the corresponding union case. + + + + + An operation representing a field-get from a union value, where that value has been proven to be of the corresponding union case. + + + + + An operation representing a coercion that proves a union value is of a particular union case. THis is not a test, its + simply added proof to enable us to generate verifiable code for field access on union types + + + + + An operation representing getting an integer tag for a union value representing the union case number + + + + + An operation representing getting the address of a record field + + + + + An operation representing getting a record field + + + + + An operation representing setting a record field + + + + + Construct a record or object-model value. The ValRef is for self-referential class constructors, otherwise + it indicates that we're in a constructor and the purpose of the expression is to + fill in the fields of a pre-created but uninitialized object, and to assign the initialized + version of the object into the optional mutable cell pointed to be the given value. + + + + + An operation representing a lambda-encoded try/finally + + + + + An operation representing a lambda-encoded try/catch + + + + + An operation representing a lambda-encoded for loop + + + + + An operation representing a lambda-encoded while loop. The special while loop marker is used to mark compilations of 'foreach' expressions + + + + + + + + Constant bytes, but a new mutable blob is generated each time the construct is executed + + + + + An operation representing the creation of an array value + + + + + An operation representing the creation of a tuple value + + + + + An operation representing the creation of an exception value using an F# exception declaration + + + + + An operation representing the creation of a union value of the particular union case + + + + + + + + Normal record construction + + + + + We're in a constructor. The purpose of the record expression is to + fill in the fields of a pre-created but uninitialized object + + + + + This ModuleOrNamespace that represents the compilation of a module as a class. + The same set of tycons etc. are bound in the ModuleOrNamespace as in the ModuleOrNamespaceExpr + This is the body of the module/namespace + + + + + + + + A named module-or-namespace-fragment definition + + + + + Indicates the module fragment is a 'rec' definition of types, values and modules + + + + + Indicates the module fragment is an evaluation of expression for side-effects + + + + + Indicates the module fragment is a 'let' definition + + + + + Indicates the module fragment is made of several module fragments in succession + + + + + Indicates the module is a module with a signature + + + + + The module_typ is a binder. However it is not used in the ModuleOrNamespaceExpr: it is only referenced from the 'outside' + The contents of a module-or-namespace-fragment definition + + + + + + + + A type for a module-or-namespace-fragment and the actual definition of the module-or-namespace-fragment + + + + + Typechecking residue: A TExpr_link occurs for every use of a recursively bound variable. While type-checking + the recursive bindings a dummy expression is stored in the mutable reference cell. + After type checking the bindings this is replaced by a use of the variable, perhaps at an + appropriate type instantiation. These are immediately eliminated on subsequent rewrites. + + + + + Typechecking residue: Indicates a free choice of typars that arises due to + minimization of polymorphism at let-rec bindings. These are + resolved to a concrete instantiation on subsequent rewrites. + + + + + + + + An intrinsic applied to some (strictly evaluated) arguments + A few of intrinsics (TOp_try, TOp_while, TOp_for) expect arguments kept in a normal form involving lambdas + + + + + If we statically know some infomation then in many cases we can use a more optimized expression + This is primarily used by terms in the standard library, particularly those implementing overloaded + operators. + + + + + Matches are a more complicated form of "let" with multiple possible destinations + and possibly multiple ways to get to each destination. + The first mark is that of the expression being matched, which is used + as the mark for all the decision making and binding that happens during the match. + + + + + + + + Bind a value. + + + + + Bind a recursive set of values. + + + + + Applications combine type and term applications, and are normalized so + that sequential applications are combined, so "(f x y)" becomes "f [[x];[y]]". + The type attached to the function is the formal function type, used to ensure we don't build application + nodes that over-apply when instantiating at function types. + + + + + + + + Lambda expressions. + + + + + Sequence expressions, used for "a;b", "let a = e in b;a" and "a then b" (the last an OO constructor). + + + + + Reference a value. The flag is only relevant if the value is an object model member + and indicates base calls and special uses of object constructors. + + + + + A constant expression. + + + + + The big type of expressions. + + + + + + + + + + + + + + + + + + + + + + + The extra metadata stored about typars for top-level definitions. Any information here is propagated from signature through + to the compiled code. + + + + + + + + + + + The extra metadata stored about typars for top-level definitions. Any information here is propagated from signature through + to the compiled code. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + A target of a decision tree. Can be thought of as a little function, though is compiled as a local block. + + + + + Run the active pattern and bind a successful result to the (one) variable in the remaining tree + + + + + Test if the input to a decision tree is an instance of the given type + + + + + Test if the input to a decision tree is null + + + + + Test if the input to a decision tree is the given constant value + + + + + Test if the input to a decision tree is an array of the given length + + + + + Test if the input to a decision tree matches the given constructor + + + + + + + + + + + + + + Bind the given value throught the remaining cases of the dtree. + + + + + Indicates the decision tree has terminated with success, calling the given target with the given parameters + + + + + Indicates a decision point in a decision tree. + + + + + Decision trees. Pattern matching has been compiled down to + a decision tree by this point. The right-hand-sides (actions) of + the decision tree are labelled by integers that are unique for that + particular tree. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Constants in expressions + + + + + + + + AttribNamedArg(name,type,isField,value) + + + + + + + + We keep both source expression and evaluated expression around to help intellisense and signature printing + + + + + + + + Attrib(kind,unnamedArgs,propVal,appliedToAGetterOrSetter,range) + + + + + Indicates an attribute refers to a type defined in an imported F# assembly + + + + + Indicates an attribute refers to a type defined in an imported .NET assembly + + + + + + + + + + + + + + + + + + + + + + + + + + + + + The result of attempting to resolve an assembly name to a full ccu. + UnresolvedCcu will contain the name of the assembly that could not be resolved. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Ensure the ccu is derefable in advance. Supply a path to attach to any resulting error message. + + + + + + + + + + + A relinkable handle to the contents of a compilation unit. Relinking is performed by mutation. + + + + + + + + + + + + + + A helper function used to link method signatures using type equality. This is effectively a forward call to the type equality + logic in tastops.fs + + + + + A handle to the full specification of the contents of the module contained in this ccu + + + + + Indicates that this DLL uses quotation literals somewhere. This is used to implement a restriction on static linking + + + + + Indicates that this DLL was compiled using the F# compiler + + + + + A hint as to where does the code for the CCU live (e.g what was the tcConfig.implicitIncludeDir at compilation time for this DLL?) + + + + + The fully qualified assembly reference string to refer to this assembly. This is persisted in quotations + + + + + A unique stamp for this DLL + + + + + Holds the data indicating how this assembly/module is referenced from the code being compiled. + + + + + Holds the filename for the DLL, if any + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Indicates the type is a variable type, whether declared, generalized or an inference type parameter + + + + + Indicates the type is a non-F#-visible type representing a "proof" that a union value belongs to a particular union case + These types are not user-visible and will never appear as an inferred type. They are the types given to + the temporaries arising out of pattern matching on union values. + + + + + Indicates the type is a function type + + + + + Indicates the type is a tuple type + + + + + Indicates the type is a type application + + + + + Indicates the type is a universal type, only used for types of values, members and record fields + + + + + The algebra of types + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Indicates a reference to something bound in another CCU + + + + + Indicates a reference to something bound in this CCU + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + References are either local or nonlocal + + + + + + + + note: ModuleOrNamespaceRef and TyconRef are type equivalent + + + + + Indicates a reference to something bound in another CCU + + + + + Indicates a reference to something bound in this CCU + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Is the destination assembly available? + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Index into the namespace/module structure of a particular CCU + + + + + + + + + + + + + + The information ILXGEN needs about the location of an item + + + + + + + + + + + + + + + + + A public path records where a construct lives within the global namespace + of a CCU. + + + + + The name of the value, or the full signature of the member + + + + + A reference to the entity containing the value or member. THis will always be a non-local reference + + + + + + + + + + + + + + + + + + + + + + + Gets updated with 'true' if an abstract slot is implemented in the file being typechecked. Internal only. + + + + + Gets updated with full slotsig after interface implementation relation is checked + + + + + The parent type. For an extension member this is the type being extended + + + + + + + + XML documentation signature for the value + + + + + XML documentation attached to a value. + + + + + + + + Top level values have an arity inferred and/or specified + signatures. The arity records the number of arguments preferred + in each position for a curried functions. The currying is based + on the number of lambdas, and in each position the elements are + based on attempting to deconstruct the type of the argument as a + tuple-type. The field is mutable because arities for recursive + values are only inferred after the r.h.s. is analyzed, but the + value itself is created before the r.h.s. is analyzed. + + TLR also sets this for inner bindings that it wants to + represent as "top level" bindings. + + + + + Custom attributes attached to the value. These contain references to other values (i.e. constructors in types). Mutable to fixup + these value references after copying a colelction of values. + + + + + Is the value actually an instance method/property/event that augments + a type, and if so what name does it take in the IL? + + + + + How visible is this? + + + + + What is the original, unoptimized, closed-term definition, if any? + Used to implement [<ReflectedDefinition>] + + + + + + + + See vflags section further below for encoding/decodings here + + + + + + + + + + + + + + + + + + + + + + + + + + + + +Get the signature for the value's XML documentation + + + + +Get the signature for the value's XML documentation + + + + + Get the declared documentation for the value + + + + + Get the type of the value including any generic type parameters + + + + + The type of the value. + May be a Type_forall for a generic value. + May be a type variable or type containing type variables during type inference. + + + + + Get the generic type parameters for the value + + + + + + + + Get the actual parent entity for the value (a module or a type), i.e. the entity under which the + value will appear in compiled code. For extension members this is the module where the extension member + is declared. + + + + + Get the type of the value after removing any generic type parameters + + + + + A unique stamp within the context of this invocation of the compiler process + + + + + + + + Get the information about the value used during type inference + + + + + The place where the value was defined. + + + + + Get the public path to the value, if any? Should be set if and only if + IsMemberOrModuleBinding is set. + + + + + - If this is a property then this is 'Foo' + - If this is an implementation of an abstract slot then this is the name of the property implemented by the abstract slot + + + + + Does the value allow the use of an explicit type instantiation (i.e. does it itself have explciti type arguments, + or does it have a signature?) + + + + + Does the inline declaration for the value indicate that the value must be inlined? + + + + + Is this a member, if so some more data about the member. + + Note, the value may still be (a) an extension member or (b) and abtract slot without + a true body. These cases are often causes of bugs in the compiler. + + + + + Get the apparent parent entity for a member + + + + + Was the value inferred to be a method or function that definitely makes no critical tailcalls? + + + + + The name of the method. + - If this is a property then this is 'get_Foo' or 'set_Foo' + - If this is an implementation of an abstract slot then this is the name of the method implemented by the abstract slot + - If this is an extension member then this will be the simple name + + + + + The value of a value or member marked with [<LiteralAttribute>] + + + + + + + + + + + + + + Was this member declared 'override' or is it an implementation of an interface slot + + + + + Was the value declared 'mutable' + + + + + Is this a value in a module, or an extension member, but excluding compiler generated bindings from optimizations + + + + + Is this a member definition or module definition? + + + + + Is this a member, if so some more data about the member. + + Note, the value may still be (a) an extension member or (b) and abtract slot without + a true body. These cases are often causes of bugs in the compiler. + + + + + + + + Is this a member, excluding extension members + + + + + Is this an instance member. + + Note, the value may still be (a) an extension member or (b) and abtract slot without + a true body. These cases are often causes of bugs in the compiler. + + + + + Is this a member generated from the de-sugaring of 'let' function bindings in the implicit class syntax? + + + + + Is this a constructor member generated from the de-sugaring of implicit constructor for a class type? + + + + + + + + + + + Is this a 'new' constructor member + + + + + Was the value generated by the compiler? + + Note: this is true for the overrides generated by hash/compare augmentations + + + + + Is this something compiled into a module, i.e. a user-defined value, an extension member or a compiler-generated value + + + + + Is this represented as a "top level" static binding (i.e. a static field, static member, + instance member), rather than an "inner" binding that may result in a closure. + + This is implied by IsMemberOrModuleBinding, however not vice versa, for two reasons. + Some optimizations mutate this value when they decide to change the representation of a + binding to be IsCompiledAsTopLevel. Second, even immediately after type checking we expect + some non-module, non-member bindings to be marked IsCompiledAsTopLevel, e.g. 'y' in + 'let x = let y = 1 in y + y' (NOTE: check this, don't take it as gospel) + + + + + Was the value ever referenced? + + + + + Is this a compiler-generated class constructor member + + + + + Get the inline declaration on the value + + + + + + + + Was the value ever referenced? + + + + + - If this is a property then this is 'Foo' + - If this is an implementation of an abstract slot then this is the name of the method implemented by the abstract slot + - If this is an operator then this is '(+)' + + + + + Range of the definition (implementation) of the value, used by Visual Studio + Updated by mutation when the implementation is matched against the signature. + + + + + The name of the method. + - If this is a property then this is 'Foo' + - If this is an implementation of an abstract slot then this is the name of the method implemented by the abstract slot + - If this is an operator then this is 'op_Addition' + + + + + The name of the method in compiled code (with some exceptions where ilxgen.fs decides not to use a method impl) + - If this is a property then this is 'get_Foo' or 'set_Foo' + - If this is an implementation of an abstract slot then this may be a mangled name + - If this is an extension member then this will be a mangled name + - If this is an operator then this is 'op_Addition' + + + + + Is this a 'base' or 'this' value? + + + + + Get the declared attributes for the value + + + + + Get the apparent parent entity for the value, i.e. the entity under with which the + value is associated. For extension members this is the nominal type the member extends. + For other values it is just the actual parent. + + + + + The parent type or module, if any (None for expression bindings and parameters) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Indicates the signature of a member constraint. Contains a mutable solution cell + to store the inferred solution of the constraint. + + + + + + + + + + + + + + + + + The specification of a member constraint that must be solved + + + + + Indicates a constraint that a type is .NET unmanaged type + + + + + Indicates a constraint that a type is a delegate from the given tuple of args to the given return type + + + + + Indicates a constraint that a type does not have the Equality(false) attribute, or is not a structural type with this attribute, with special rules for some known structural container types + + + + + Indicates a constraint that a type implements IComparable, with special rules for some known structural container types + + + + + Indicates a constraint that a type is an enum with the given underlying + + + + + Indicates a constraint that a type has a parameterless constructor + + + + + Indicates a constraint that a type is a simple choice between one of the given ground types. See format.fs + + + + + Indicates a constraint that a type is a reference type + + + + + Indicates a constraint that a type is a non-Nullable value type + These are part of .NET's model of generic constraints, and in order to + generate verifiable code we must attach them to F# generalzied type variables as well. + + + + + Indicates a constraint that a type has a member with the given signature + + + + + Indicates a constraint that a type has a 'null' value + + + + + Indicates a default value for an inference type variable should it be netiher generalized nor solved + + + + + Indicates a constraint that a type is a subtype of the given type + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + The inferred constraints for the type inference variable + + + + + An inferred equivalence for a type inference variable. + + + + + The declared attributes of the type parameter. Empty for type inference variables. + + + + + The documentation for the type parameter. Empty for type inference variables. + + + + + The unique stamp of the typar blob. + + + + + + + + + + + + + + + + + Indicates the construct can only be accessed from any code in the given type constructor, module or assembly. [] indicates global scope. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Mutation used during compilation of FSharp.Core.dll + + + + + + + + + + + + + + + + + + + + + + + + + + Namespace or module-compiled-as-type? + + + + + + + + + + + + + + + + + + + + + + + Values, including members in F# types in this module-or-namespace-fragment. + + + + + + + + + + + Type, mapping mangled name to Tycon, e.g. + + + + + + + + + + + + + + + + + Mutation used during compilation of FSharp.Core.dll + + + + + + + + + + + + + + Indicates that a 'module' is really a namespace + + + + + Indicates that a module is compiled to a class with the same name as the original module + + + + + Indicates that a module is compiled to a class with the "Module" suffix added. + + + + + + + + Indicates that an exception is abstract, i.e. is in a signature file, and we do not know the representation + + + + + Indicates that an exception carries the given record of values + + + + + Indicates that an exception is shorthand for the given .NET exception type + + + + + Indicates that an exception is an abbreviation for the given exception + + + + + + + + Name/declaration-location of the field + + + + + Attributes attached to generated field + + + + + Attributes attached to generated property + + + + + Indicates the declared visibility of the field, not taking signatures into account + + + + + The default initialization info, for static literals + + + + + Indicates a compiler generated field, not visible to Intellisense or name resolution + + + + + Indicates a volatile field + + + + + Indicates a static field + + + + + The type of the field, w.r.t. the generic parameters of the enclosing type constructor + + + + + XML Documentation signature for the field + + + + + Documentation for the field + + + + + Is the field declared mutable in F#? + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + This may represent a "field" in either a struct, class, record or union + It is normally compiled to a property. + + + + + Attributes, attached to the generated static method to make instances of the case + + + + + Indicates the declared visibility of the union constructor, not taking signatures into account + + + + + Name/range of the case + + + + + XML documentation signature for the case + + + + + Documentation for the case + + + + + Name of the case in generated IL code + + + + + Return type constructed by the case. Normally exactly the type of the enclosing type, sometimes an abbreviation of it + + + + + Data carried by the case. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + The cases contained in the discriminated union. + + + + + The ILX data structure representing the discriminated union. + + + + + + + + The cases of the discriminated union, indexed by name. + + + + + The cases of the discriminated union, in declaration order. + + + + + + + + + + + + + + The fields of the record, indexed by name. + + + + + The fields of the record, in declaration order. + + + + + + + + + + + + + + + + + + + + + + + The fields of the class, struct or enum + + + + + The declared abstract slots of the class, interface or struct + + + + + Indicates whether the type declaration is a class, interface, enum, delegate or struct + + + + + + + + Indicates the type is an enumeration + + + + + Indicates the type is a delegate with the given Invoke signature + + + + + Indicates the type is a struct + + + + + Indicates the type is an interface + + + + + Indicates the type is a class (also used for units-of-measure) + + + + + + + + Indicates the type is parameterized on a measure (e.g. float<_>) but erases to some other type (e.g. float) + + + + + Indicates the type is implemented as IL assembly code using the given closed Abstract IL type + + + + + Indicates the type is a .NET type + + + + + Indicates the type is a discriminated union + + + + + Indicates the type is a record + + + + + Indicates the type is a class, struct, enum, delegate or interface + + + + + + + + Set to true if the type is determined to be abstract + + + + + Set to true at the end of the scope where proper augmentations are allowed + + + + + Super type, if any + + + + + Interface implementations - boolean indicates compiler-generated + + + + + Properties, methods etc. as lookup table + + + + + Properties, methods etc. in declaration order + + + + + True if the type defined an Object.GetHashCode method. In this + case we give a warning if we auto-generate a hash method since the semantics may not match up + + + + + This is the value implementing the auto-generated comparison + semantics if any. It is not present if the type defines its own implementation + of IStructuralEquatable or if the type doesn't implement IComparable implicitly. + + + + + This is the value implementing the auto-generated equality + semantics if any. It is not present if the type defines its own implementation + of Object.Equals or if the type doesn't override Object.Equals implicitly. + + + + + This is the value implementing the auto-generated comparison + semantics if any. It is not present if the type defines its own implementation + of IStructuralComparable or if the type doesn't implement IComparable implicitly. + + + + + This is the value implementing the auto-generated comparison + semantics if any. It is not present if the type defines its own implementation + of IComparable or if the type doesn't implement IComparable implicitly. + + + + + + + + + + + + + + + + + Used during codegen to hold the ILX representation indicating how to access the type + + + + + The stable path to the type, e.g. Microsoft.FSharp.Core.FSharpFunc`2 + + + + + + + + The stable path to the type, e.g. Microsoft.FSharp.Core.FSharpFunc`2 + + + + + The XML document signature for this entity + + + + + The declared documentation for the type or module + + + + + This field is used when the 'tycon' is really a module definition. It holds statically nested type definitions and nested modules + + + + + Field used when the 'tycon' is really an exception definition + + + + + The methods and properties of the type + + + + + If non-None, indicates the type is an abbreviation for another type. + + + + + The declared representation of the type, i.e. record, union, class etc. + + + + + The declared attributes for the type + + + + + The declared accessibility of the representation, not taking signatures into account + + + + + The declaration location for the type constructor + + + + + The name of the type, possibly with `n mangling + + + + + The name of the type, possibly with `n mangling + + + + + The unique stamp of the "tycon blob". Note the same tycon in signature and implementation get different stamps + + + + + + + + + + + The declared type parameters of the type + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Note: result is alphabetically sorted, then for each name the results are in declaration order + + + + + Note: result is a indexed table, and for each name the results are in reverse declaration order + + + + + + + + + + + + + + + + + + + + Indicates the type prefers the "tycon<a,b>" syntax for display etc. + + + + + + + + Indicates the "tycon blob" is actually a module + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + From TAST TyconRef to IL ILTypeRef + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Get the flags as included in the F# binary metadata + + + + + + + + + + + + + + + + + + + + Encode entity flags into a bit field. We leave lots of space to allow for future expansion. + + + + + + + + + + + + + + Get the flags as included in the F# binary metadata. We pickle this as int64 to allow for future expansion + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Encode typar flags into a bit field + + + + + Indicates the type parameter derives from an '_' anonymous type + For units-of-measure, we give a warning if this gets solved to '1' + + + + + Indicates the type parameter is an inference variable may be solved + + + + + Indicates we give a warning if the type parameter is ever solved + + + + + Indicates the type parameter can't be solved, but the variable is not set to "rigid" until after inference is complete + + + + + Indicates the type parameter can't be solved + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Get the flags as included in the F# binary metadata + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Indicates the 'this' value specified in a memberm e.g. 'x' in 'member x.M() = 1' + + + + + Indicates a normal value + + + + + Indicates the value called 'base' available for calling base class members + + + + + Indicates a ref-cell holding 'this' or the implicit 'this' used throughout an + implicit constructor to access and set values + + + + + + + + Indicates the type parameter is needed at runtime and may not be eliminated + + + + + Indicates the type parameter is not needed at runtime and may be eliminated + + + + + + + + + + + + + + + + + The normal value for this flag when the value is not within its recursive scope + + + + + Set while the value is within its recursive scope. The flag indicates if the value has been eagerly generalized and accepts generic-recursive calls + + + + + + + + + + + + + + Indictes the value is inlined but the code for the function still exists, e.g. to satisfy interfaces on objects, but that it is also always inlined + + + + + Indicates the value must always be inlined + + + + + + + + + + + + + + Unique name generator for stamps attached to lambdas and object expressions + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Primitive routine to compare two EntityRef's for equality + This takes into account the possibility that they may have type forwarders + + + + + This predicate tests if non-local resolution paths are definitely known to resolve + to different entities. All references with different named paths always resolve to + different entities. Two references with the same named paths may resolve to the same + entities even if they reference through different CCUs, because one reference + may be forwarded to another via a .NET TypeForwarder. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Equality on CCU references, implemented as reference equality except when unresolved + + + + + + + + + + + + + + + + + + + + + + + Unique name generator for stamps attached to to val_specs, tycon_specs etc. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Metadata on values (names of arguments etc. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/packages/FSPowerPack.Community.2.0.0.0/Lib/Net40/FSharp.PowerPack.Parallel.Seq.dll b/packages/FSPowerPack.Community.2.0.0.0/Lib/Net40/FSharp.PowerPack.Parallel.Seq.dll new file mode 100644 index 0000000000000000000000000000000000000000..b830f584380ce91790a9284d11814ea21fef6d98 Binary files /dev/null and b/packages/FSPowerPack.Community.2.0.0.0/Lib/Net40/FSharp.PowerPack.Parallel.Seq.dll differ diff --git a/packages/FSPowerPack.Community.2.0.0.0/Lib/Net40/FSharp.PowerPack.Parallel.Seq.xml b/packages/FSPowerPack.Community.2.0.0.0/Lib/Net40/FSharp.PowerPack.Parallel.Seq.xml new file mode 100644 index 0000000000000000000000000000000000000000..d60554eed4dec77300414fd461adf8ad513a92a3 --- /dev/null +++ b/packages/FSPowerPack.Community.2.0.0.0/Lib/Net40/FSharp.PowerPack.Parallel.Seq.xml @@ -0,0 +1,817 @@ + + +FSharp.PowerPack.Parallel.Seq + + + + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + Operates in parallel, using System.Linq.Parallel. 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. + Operates in parallel, using System.Linq.Parallel. 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. + Operates in parallel, using System.Linq.Parallel. 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. + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + Operates in parallel, using System.Linq.Parallel. 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. + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + Operates in parallel, using System.Linq.Parallel. 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. + Operates in parallel, using System.Linq.Parallel. 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. + Operates in parallel, using System.Linq.Parallel. 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. + Operates in parallel, using System.Linq.Parallel. 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. + Operates in parallel, using System.Linq.Parallel. 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. + + + + + + + + + + + + + + + + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. Builds a list from the given collection. + + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + + + Operates in parallel, using System.Linq.Parallel. Builds an array from the given collection. + + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. Returns a sequence that yields one item only. + + The input item. + + The result sequence. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. Views the given list as a sequence. + + The input list. + + The result sequence. + + + Operates in parallel, using System.Linq.Parallel. Views the given array as a sequence. + + The input array. + + The result sequence. + + Thrown when the input sequence is null. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. Returns the lengthof the sequence + + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. Returns true if the sequence contains no elements, false otherwise. + + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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 + + + Operates in parallel, using System.Linq.Parallel. 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 + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. Creates an empty sequence. + + The result sequence. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Parallel operations on IEnumerables. + + + diff --git a/packages/FSPowerPack.Community.2.0.0.0/Lib/Net40/FSharp.PowerPack.dll b/packages/FSPowerPack.Community.2.0.0.0/Lib/Net40/FSharp.PowerPack.dll new file mode 100644 index 0000000000000000000000000000000000000000..0e4b2eb7940ad53fd00f446b7b392b9430189cb4 Binary files /dev/null and b/packages/FSPowerPack.Community.2.0.0.0/Lib/Net40/FSharp.PowerPack.dll differ diff --git a/packages/FSPowerPack.Community.2.0.0.0/Lib/Net40/FSharp.PowerPack.xml b/packages/FSPowerPack.Community.2.0.0.0/Lib/Net40/FSharp.PowerPack.xml new file mode 100644 index 0000000000000000000000000000000000000000..0293bac7a5062e7ae5c0117482d4c977cd8eb480 --- /dev/null +++ b/packages/FSPowerPack.Community.2.0.0.0/Lib/Net40/FSharp.PowerPack.xml @@ -0,0 +1,5118 @@ + + +FSharp.PowerPack + + + + Lookup or set the given element in the table. Set replaces all existing bindings for a value with a single + bindings. Raise <c>KeyNotFoundException</c> if the element is not found. + + + + + Lookup or set the given element in the table. Set replaces all existing bindings for a value with a single + bindings. Raise <c>KeyNotFoundException</c> if the element is not found. + + + + + The total number of keys in the hash table + + + + + Lookup the given element in the table, returning the result as an Option + + + + + Replace the latest binding (if any) for the given element. + + + + + Remove the latest binding (if any) for the given element from the table + + + + +Apply the given function to each binding in the hash table + + + + + Apply the given function to each element in the collection threading the accumulating parameter + through the sequence of function applications + + + + + Find all bindings for the given element in the table, if any + + + + + + + + + + + + + + Make a shallow copy of the collection + + + + + Test if the collection contains any bindings for the given element + + + + + Clear all elements from the collection + + + + + Add a binding for the element to the table + + + + + + + + + + + + + + Build a map that contains the bindings of the given IEnumerable + + + + + Create a new empty mutable HashMultiMap with an internal bucket array of the given approximate size + and with the given key hash/equality functions + + + + + Create a new empty mutable HashMultiMap with the given key hash/equality functions + + + + + Hash tables, by default based on F# structural "hash" and (=) functions. + The table may map a single key to multiple bindings. + + + + + The total number of elements in the set + + + + + Remove the given element from the set + + + + + Apply the given function to each binding in the hash table + + + + + Apply the given function to the set threading the accumulating parameter + through the sequence of function applications + + + + + Make a shallow copy of the set + + + + + Test if the set contains the given element + + + + + Clear all elements from the set + + + + + Add an element to the collection + + + + + + + + + + + + + + Create a new mutable hash set with the given elements and using the given key hash/equality functions + + + + + Create a new empty mutable hash set with an internal bucket array of the given approximate size + and with the given key hash/equality functions + + + + + Create a new empty mutable hash set using the given key hash/equality functions + + + + + Mutable hash sets based by default on F# structural "hash" and (=) functions. Implemented via a hash table and/or Dictionary. + + + + + LazyLists are possibly-infinite, cached sequences. See also IEnumerable/Seq for + uncached sequences. LazyLists normally involve delayed computations without + side-effects. The results of these computations are cached and evaluations will be + performed only once for each element of the lazy list. In contrast, for sequences + (IEnumerable) recomputation happens each time an enumerator is created and the sequence + traversed. + + LazyLists can represent cached, potentially-infinite computations. Because they are + cached they may cause memory leaks if some active code or data structure maintains a + live reference to the head of an infinite or very large lazy list while iterating it, + or if a reference is maintained after the list is no longer required. + + Lazy lists may be matched using the LazyList.Cons and LazyList.Nil active patterns. + These may force the computation of elements of the list. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Build a new collection from the given enumerable object + + + + + Return a view of the collection as an enumerable object + + + + + Build a non-lazy list from the given collection. This function will eagerly evaluate all of the + list (and thus may not terminate). + + + + + Build a collection from the given list. This function will eagerly evaluate all of the + list (and thus may not terminate). + + + + + Build an array from the given collection + + + + + Build a collection from the given array. This function will eagerly evaluate all of the + list (and thus may not terminate). + + + + + Build a new collection whose elements are the results of applying the given function + to the corresponding elements of the two collections pairwise. + + + + + Build a new collection whose elements are the results of applying the given function + to each of the elements of the collection. + + + + + Return a new list consisting of the results of applying the given accumulating function + to successive elements of the list + + + + + Apply the given function to each element of the collection. + + + + + Return a new collection which on consumption will consist of only the elements of the collection + for which the given predicate returns "true" + + + + + Return the list which contains on demand the list of elements of the list of lazy lists. + + + + + Return the list which contains on demand the pair of elements of the first and second list + + + + + Return the list which contains on demand the elements of the first list followed + by the elements of the second list + + + + + Return a list that contains the elements returned by the given computation. + The given computation is not executed until the first element on the list is + consumed. The given argument is passed to the computation. Subsequent elements + in the list are generated by again applying the residual 'b to the computation. + + + + + Return a list that is in effect the list returned by the given computation. + The given computation is not executed until the first element on the list is + consumed. + + + + + Return the list which on consumption will consist of an infinite sequence of + the given item + + + + + Return a new list which on consumption contains the given item + followed by the list returned by the given computation. The + + + + + Return a new list which contains the given item followed by the + given list. + + + + + Return the length of the list + + + + + Evaluates to the list that contains no items + + + + + Return the first element for which the given function returns <c>true</c>. + Raise <c>KeyNotFoundException</c> if no such element exists. + + + + + Apply the given function to successive elements of the list, returning the first + result where function returns <c>Some(x)</c> for some x. If the function never returns + true, 'None' is returned. + + + + + Return the list which on consumption will skip the first 'n' elements of + the input list. + + + + + Return the list which on consumption will consist of at most 'n' elements of + the input list. + + + + + Get the first cell of the list. + + + + + Return the list corresponding to the remaining items in the sequence. + Forces the evaluation of the first cell of the list if it is not already evaluated. + + + + + Return the first element of the list. Forces the evaluation of + the first cell of the list if it is not already evaluated. + + + + + Test if a list is empty. Forces the evaluation of + the first element of the stream if it is not already evaluated. + + + + + + + + Split an array of pairs into two arrays + + + + + Combine the two arrays into an array of pairs. The two arrays must have equal lengths, otherwise an <c>ArgumentException</c> is + raised.. + + + + + Return the index of the first element in the array + that satisfies the given predicate. + + + + + Return the index of the first element in the array + that satisfies the given predicate. + + + + + Return an array containing the given element + + + + + Like <c>foldBack</c>, but return both the intermediary and final results + + + + + Like <c>fold</c>, but return the intermediary and final results + + + + + Build 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 <c>ArgumentException</c> is + raised. + + + + + Apply 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 <c>ArgumentException</c> is raised. + + + + + Return true if the given array is empty, otherwise false + + + + + Test elements of the two arrays pairwise to see if all pairs of elements satisfy the given predicate. + Raise ArgumentException if the arrays have different lengths. + + + + + 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 <c>ArgumentException</c> is + raised. + + + + + Apply 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 <c>ArgumentException</c> is + raised. + + + + + Apply a function to each element of the array, threading an accumulator argument + through the computation. If the input function is <c>f</c> and the elements are <c>i0...iN</c> then + computes <c>f i0 (...(f iN-1 iN))</c>. Raises ArgumentException if the array has size zero. + + + + + Apply a function to each element of the array, threading an accumulator argument + through the computation. If the input function is <c>f</c> and the elements are <c>i0...iN</c> + then computes <c>f (... (f i0 i1)...) iN</c>. Raises ArgumentException if the array has size zero. + + + + + Return the index of the first element in the array + that satisfies the given predicate. Raise <c>KeyNotFoundException</c> if + none of the elements satisfy the predicate. + + + + + Return the index of the first element in the array + that satisfies the given predicate. Raise <c>KeyNotFoundException</c> if + none of the elements satisfy the predicate. + + + + + Test elements of the two arrays pairwise to see if any pair of element satisfies the given predicate. + Raise ArgumentException if the arrays have different lengths. + + + + + + + + Return a view of the array as an enumerable object + + + + + Build a ResizeArray from the given elements + + + + + Return a fixed-length array containing the elements of the input ResizeArray + + + + + Sort the elements using the key extractor and generic comparison on the keys + + + + + Sort the elements using the given comparison function + + + + +Return a new array with the elements in reverse order + + + + +Split a list of pairs into two lists + + + + +Combine the two arrays into an array of pairs. The two arrays must have equal lengths. + + + + +Apply the given function to successive elements, returning the first +result where function returns "Some(x)" for some x. + + + + +Return the first element for which the given function returns <c>true</c>. +Return None if no such element exists. + + + + +Return the first element for which the given function returns <c>true</c>. +Raise <c>KeyNotFoundException</c> if no such element exists. + + + + +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) + + + + +Split the collection into two collections, containing the +elements for which the given predicate returns <c>true</c> and <c>false</c> +respectively + + + + +Return a new collection containing only the elements of the collection +for which the given predicate returns <c>true</c> + + + + + Test if all elements of the array satisfy the given predicate. + If the input function is <c>f</c> and the elements are <c>i0...iN</c> and "j0...jN" + then computes <c>p i0 && ... && p iN</c>. + + + + + Test if any element of the array satisfies the given predicate. + If the input function is <c>f</c> and the elements are <c>i0...iN</c> + then computes <c>p i0 or ... or p iN</c>. + + + + +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. + + + + +Apply the given function to each element of the array. The integer passed to the +function indicates the index of element. + + + + +Build 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. + + + + +Apply the given function to two arrays simultaneously. The +two arrays must have the same lengths, otherwise an Invalid_argument exception is +raised. + + + + +Build a new array whose elements are the results of applying the given function +to each of the elements of the array. + + + + +Apply the given function to each element of the array. + + + + + Apply a function to each element of the array, threading an accumulator argument + through the computation. If the input function is <c>f</c> and the elements are <c>i0...iN</c> then + computes <c>f i0 (...(f iN s))</c>. + + + + + Apply a function to each element of the collection, threading an accumulator argument + through the computation. If the input function is <c>f</c> and the elements are <c>i0...iN</c> + then computes <c>f (... (f s i0)...) iN</c> + + + + +Build and array from the given seq + + + + + + + +Build an array from the given list + + + + + + + +Build a list from the given array + + + + +Read a range of elements from the first array and write them into the second. + + + + +Fill a range of the collection with the given element + + + + +Build a new array that contains the elements of the given array + + + + +Build a new array that contains the given subrange specified by +starting index and length. + + + + +Build a new array that contains the elements of each of the given list of arrays + + + + +Build a new array that contains the elements of the first array followed by the elements of the second array + + + + + Create an array by calling the given generator on each index. + + + + + Create an array whose elements are all initially the given value. + + + + + Set the value of an element in the collection. You can also use the syntax <c>arr.[idx] <- e</c>. + + + + + Fetch an element from the collection. You can also use the syntax <c>arr.[idx]</c>. + + + + + Return the length of the collection. You can also use property <c>arr.Length</c>. + + + + + Generic operations on the type System.Collections.Generic.List, which is called ResizeArray in the F# libraries. + + + + + + + + Lookup or set the given element in the table. Raise <c>KeyNotFoundException</c> if the element is not found. + + + + + Lookup or set the given element in the table. Raise <c>KeyNotFoundException</c> if the element is not found. + + + + + The number of bindings in the hash table + + + + + Lookup the given element in the table, returning the result as an Option + + + + + Replace the latest binding (if any) for the given element. + + + + + Remove the latest binding (if any) for the given element from the table + + + + + Apply the given function to each binding in the hash table + + + + + Apply the given function to each element in the collection threading the accumulating parameter + through the sequence of function applications + + + + + Find all bindings for the given element in the table, if any + + + + + Create a new empty mutable hash table with an internal bucket array of the given approximate size + and with the given key hash/equality functions + + + + + Make a shallow copy of the collection + + + + + Test if the collection contains any bindings for the given element + + + + + Test if the collection contains any bindings for the given element + + + + + Clear all elements from the collection + + + + + Add a binding for the element to the table + + + + + HashMultiMap, but where a constraint tag tracks information about the hash/equality functions used + for the hashing. When the tag is Tags.StructuralHash this is identical to HashMultiMap. + + + + + + + + The number of elements in the set + + + + + Remove the given element from the set + + + + + Apply the given function to each binding in the hash table + + + + + Apply the given function to the set threading the accumulating parameter + through the sequence of function applications + + + + + Create a new empty mutable hash set with an internal bucket array of the given approximate size + and with the given key hash/equality functions + + + + + Make a shallow copy of the set + + + + + Test if the set contains the given element + + + + + Clear all elements from the set + + + + + Add an element to the collection + + + + + Mutable hash sets where a constraint tag tracks information about the hash/equality functions used + for the hashing. When the tag is Tags.StructuralHash this is identical to HashSet. + + + + + + + + Lookup an element in the map. Raise <c>KeyNotFoundException</c> if no binding + exists in the map. + + + + + Gets a value indicating whether there are no bindings in the map. + + + + + The number of bindings in the map + + + + + Gets the comparer used for the map. + + + + + Lookup an element in the map, returning a <c>Some</c> value if the element is in the domain + of the map and <c>None</c> if not. + + + + + The elements of the set as a list. + + + + + The elements of the set as an array + + + + + Remove an element from the domain of the map. No exception is raised if the element is not present. + + + + + Build two new maps, one containing the bindings for which the given predicate returns 'true', + and the other the remaining bindings. + + + + + Build a new collection whose elements are the results of applying the given function + to each of the elements of the collection. + + + + + Build a new collection whose elements are the results of applying the given function + to each of the elements of the collection. The index passed to the + function indicates the index of element being transformed. + + + + + Apply the given function to each binding in the dictionary + + + + + + + + Return true if the given predicate returns true for all of the + bindings in the map. Always returns true if the map is empty. + + + + + Given the start and end points of a key range, + Fold over the bindings in the map that are in the range, + and the end points are included if present (the range is considered a closed interval). + + + + + Fold over the bindings in the map. + + + + + Fold over the bindings in the map. + + + + + Search the map looking for the first element where the given function returns a <c>Some</c> value + + + + + Build a new map containing the bindings for which the given predicate returns 'true'. + + + + + Return true if the given predicate returns true for one of the + bindings in the map. Always returns false if the map is empty. + + + + + + + + The empty map, and use the given comparer comparison function for all operations associated + with any maps built from this map. + + + + + Build a map that contains the bindings of the given IEnumerable + and where comparison of elements is based on the given comparison function + + + + + Test is an element is in the domain of the map + + + + + Return a new map with the binding added to the given map. + + + + + Immutable maps. Keys are ordered by construction function specified + when creating empty maps or by F# structural comparison if no + construction function is specified. + + <performance> + Maps based on structural comparison are + efficient for small keys. They are not a suitable choice if keys are recursive data structures + or require non-structural comparison semantics. + </performance> + Immutable maps. A constraint tag carries information about the class of key-comparers being used. + + + + + + + + Return a new set with the elements of the second set removed from the first. + + + + + Compute the union of the two 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. + + + + + Return the number of elements in the set + + + + + Gets the comparer used for the set. + + + + + The number of elements in the set + + + + + Compute the union of the two sets. + + + + + The elements of the set as a list. + + + + + The elements of the set as an array. + + + + + A singleton set based on the given comparison operator + + + + + 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. + + + + + Build two new sets, one containing the elements for which the given predicate returns 'true', + and the other the remaining elements. + + + + + Apply the given function to each binding in the collection + + + + + Evaluates to "true" if all elements of the first set are in the second + + + + + Evaluates to "true" if all elements of the second set are in the first + + + + + Compute the intersection of the two sets. + + + + + Test if all elements of the collection satisfy the given predicate. + If the input function is <c>f</c> and the elements are <c>i0...iN</c> and <c>j0...jN</c> then + computes <c>p i0 && ... && p iN</c>. + + + + + Apply the given accumulating function to all the elements of the set + + + + + Return a new collection containing only the elements of the collection + for which the given predicate returns "true" + + + + + Test if any element of the collection satisfies the given predicate. + If the input function is <c>f</c> and the elements are <c>i0...iN</c> then computes + <c>p i0 or ... or p iN</c>. + + + + + + + + Compares two sets and returns true if they are equal or false otherwise + + + + + The empty set based on the given comparer + + + + + Return a new set with the elements of the second set removed from the first. + + + + + A set based on the given comparer containing the given initial elements + + + + + A useful shortcut for Set.contains. See the Set module for further operations on sets. + + + + + Compares a and b and returns 1 if a > b, -1 if b < a and 0 if a = b + + + + + A useful shortcut for Set.add. Note this operation prodcues 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. + + + + + Immutable sets based on binary trees, default tag + Immutable sets where a constraint tag carries information about the class of key-comparer being used. + + + + + Wait for the result and commit it + + + + + Record the result in the AsyncResultCell. Subsequent sets of the result are ignored. + + This may result in the scheduled resumption of a waiting asynchronous operation + + + + + Create a new result cell + + + + + A helper type to store a single result from an asynchronous computation and asynchronously + access its result. + + + + + + + + + + + + + + Create an async whose result depends on the value of an AsyncResult. + + + + + Represents the reified result of an asynchronous computation + + + + + An async that produces true if the reader is at the end of stream and false otherwise + + Note that when the async is run it reflects the reader state at the time of running; multiple runs will + yield different results. + + + + + + + + + + + Creates an async that read all characters in the stream up to the end. + + Note that when the async is run it reflects the reader state at the time of running; multiple runs will + yield different results. + + + + + Creates an async that reads next line from the stream + + Note that when the async is run it reflects the reader state at the time of running; multiple runs will + yield different results. + + + + + Creates an async that reads exactly <c>count</c> characters from the stream unless end of stream is reached and puts them + into <c>buffer</c> starting at <c>index</c>. The async returns the number of characters that are read (if end-of-stream is not reached + that will be <c>count</c> + + Note that when the async is run it reflects the reader state at the time of running; multiple runs will + yield different results. + + + + + Creates an async that reads all the charactes that are avilable in the stream up to <c>count</c characters and puts them + into <c>buffer</c> starting at <c>index</c>. The async returns the number of characters that are read. + + Note that when the async is run it reflects the reader state at the time of running; multiple runs will + yield different results. + + + + + Creates an async that reads next character from the stream + + Note that when the async is run it reflects the reader state at the time of running; multiple runs will + yield different results. + + + + + Creates an async that produces next character from the stream without advancing the stream + + Note that when the async is run it reflects the reader state at the time of running; multiple runs will + yield different results. + + + + +. DiscardBufferedData tells StreamReader to throw away its internal +. buffer contents. This is useful if the user needs to seek on the + underlying stream to a known location then wants the StreamReader + to start reading from this new point. This method should be called + very sparingly, if ever, since it can lead to very poor performance. + However, it may be the only way of handling some scenarios where + users need to re-read the contents of a StreamReader a second time. + + + + + + + + + + + + + + + + + + + + Creates a new AsyncStreamReader for the given stream. The + character encoding is set by encoding and the buffer size, + in number of 16-bit characters, is set by bufferSize. + + Note that detectEncodingFromByteOrderMarks is a very + loose attempt at detecting the encoding by looking at the first + 3 bytes of the stream. It will recognize UTF-8, little endian + unicode, and big endian unicode text, but that's it. If neither + of those three match, it will use the Encoding you provided. + + + + + Implements a TextReader-like API that asynchronously reads characters from + a byte stream in a particular encoding. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + See Lazy.Force + + + + + + + + + + + Return the given rational number + + + + + Return the negation of a rational number + + + + + Return the difference of two rational numbers + + + + + Return the product of two rational numbers + + + + + This operator is for use from other .NET languages + + + + + This operator is for use from other .NET languages + + + + + This operator is for use from other .NET languages + + + + + This operator is for use from other .NET languages + + + + + This operator is for use from other .NET languages + + + + + Return the result of converting the given rational number to an integer + + + + + Return the result of converting the given rational number to a big integer + + + + + Return the result of converting the given rational number to a floating point number + + + + + This operator is for use from other .NET languages + + + + + Return the ratio of two rational numbers + + + + + Return the sum of two rational numbers + + + + + Get zero as a rational number + + + + + + + + Return the sign of a rational number; 0, +1 or -1 + + + + + Get one as a rational number + + + + + Return the numerator of the normalized rational number + + + + + Return a boolean indicating if this rational number is strictly positive + + + + + Return a boolean indicating if this rational number is strictly negative + + + + + Return the denominator of the normalized rational number + + + + + + + + Return the result of converting the given rational number to an integer + + + + + Return the result of converting the given rational number to a floating point number + + + + + Return the result of converting the given rational number to a big integer + + + + + Return the result of raising the given rational number to the given power + + + + + Return the result of converting the string to a rational number + + + + + + + + Return the result of converting the given integer to a rational number + + + + + Return the result of converting the given big integer to a rational number + + + + + Return the absolute value of a rational number + + + + + The type of arbitrary-sized rational numbers + + + + + Unary negation of a complex number + + + + + Subtract one complex number from another + + + + + Multiply a complex number by a scalar + + + + + Multiply a scalar by a complex number + + + + + Multiply two complex numbers + + + + + Complex division of two complex numbers + + + + + Add two complex numbers + + + + + The real part of a complex number + + + + + The imaginary part of a complex number + + + + + The complex number 0+0i + + + + + The real part of a complex number + + + + + The polar-coordinate phase of a complex number + + + + + The complex number 0+1i + + + + + The complex number 1+0i + + + + + The polar-coordinate magnitude of a complex number + + + + + The imaginary part of a complex number + + + + + The conjugate of a complex number, i.e. x-yi + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Create a complex number using magnitude/phase polar coordinates + + + + + Create a complex number x+ij using rectangular coordinates + + + + + + + + Computes the absolute value of a complex number: e.g. Abs x+iy = sqrt(x**2.0 + y**2.0.) + Note: Complex.Abs(z) is the same as z.Magnitude + + + + + The type of complex numbers stored as pairs of 64-bit floating point numbers in rectangular coordinates + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Get the item at the given position in a matrix + + + + + Prefix '+' operator. A nop. + + + + + Matrix negation. + + + + + Point-wise subtraction of two matrices. An InvalidArgument exception will be + raised if the dimensions do not match. + + + + + Multiply each element of a matrix by a scalar value + + + + + Multiply each element of a matrix by the given scalar value + + + + + Matrix-vector multiplication. + + + + + Matrix multiplication. An InvalidArgument exception will be + raised if the dimensions do not match. + + + + + Point-wise matrix multiplication. An InvalidArgument exception will be + raised if the dimensions do not match. + + + + + Point-wise addition of two matrices. An InvalidArgument exception will be + raised if the dimensions do not match. + + + + + Get the transpose of a matrix. + + + + + + + + Get the number of rows in a matrix + + + + + Get the number of columns in a matrix + + + + + Returns sqrt(sum(norm(x)*(norm(x))) of all the elements of a matrix. + The element type of a matrix must have an associated instance of INormFloat<'T> (see <c>GlobalAssociations</c>) ((else NotSupportedException)). + + + + + Return the non-zero entries of a sparse or dense matrix + + + + + Get the item at the given position in a matrix + + + + + Indicates if a matrix uses the sparse representation. + + + + + Indicates if a matrix uses the dense representation. + + + + + Get the internal array of values for a sparse matrix. This property + should only be used when interoperating with other matrix libraries. + + + + + Get the internal array of row offsets for a sparse matrix. This property + should only be used when interoperating with other matrix libraries. + + + + + Get the internal array of column values for a sparse matrix. This property + should only be used when interoperating with other matrix libraries. + + + + + Get the internal array of values for a dense matrix. This property + should only be used when interoperating with other matrix libraries. + + + + + Retrieve the dictionary of numeric operations associated with the element + type of this matrix. Accessing the property may raise an NotSupportedException if the element + type doesn't support any numeric operations. The object returned + may support additional numeric operations such as IFractional: + this can be determined by a dynamic type test against the object + returned. + + + + + Get the number of (rows,columns) in a matrix + + + + + Get the main diagonal of a matrix, as a vector + + + + + Convert a matrix to a column vector + + + + + Convert a matrix to a row vector + + + + + Return a new array containing the elements of a matrix + + + + + + + + Supports the slicing syntax 'A.[idx1..idx2,idx1..idx2] <- B' + + + + + Select a range of rows from a matrix + + + + + Select a row from a matrix + + + + + Select a region from a matrix + + + + + Permutes the rows of a matrix. + + + + + Permutes the columns of a matrix. + + + + + Supports the slicing syntax 'A.[idx1..idx2,idx1..idx2]' + + + + + + + + Return the nth diagonal of a matrix, as a vector. Diagonal 0 is the primary + diagonal, positive diagonals are further to the upper-right of a matrix. + + + + + + + + Create a new matrix that is a copy of an array + + + + + Select a range of columns from a matrix + + + + + Select a column from a matrix + + + + + The type of matrices. The arithmetic operations on the element type are determined by inspection on the element type itself. + Two representations are supported: sparse and dense. + + + + + A permutation of a finite range of integers 0 .. N-1, represented by a mapping of index positions + + + + + + + + Return a row vector, unchanged + + + + + Point-wise negation of a row vector + + + + + Point-wise subtraction of two row vectors + + + + + Multiply a scalar by a row vector + + + + + Multiply a row vector by a scalar + + + + + Multiply a row vector by a matrix + + + + + Multiply a row vector by a vector + + + + + Point-wise multiplication of two row vectors + + + + + Point-wise addition of two row vectors + + + + + Get the transpose of the row vector. + + + + + + + + + + + + + + + + + Get the underlying internal array of values for a vector. This property + should only be used when interoperating with other matrix libraries. + + + + + + + + Return a new array containing a copy of the elements of a vector + + + + + Supports the slicing syntax 'rv.[idx1..idx2] <- rv2' + + + + + Permute the elements of the row vector. + + + + + Supports the slicing syntax 'rv.[idx1..idx2]' + + + + + + + + + + + Create a new matrix that is a copy of a array + + + + + The type of row vectors. + + + + + Gets an item from a vector + + + + + Return the input vector + + + + + Negate a vector + + + + + Subtract two vectors, pointwise + + + + + Multiply a vector by a scalar + + + + + Multiply a column vector and a row vector to produce a matrix + + + + + Multiply each element of a vector by a scalar value. + + + + + Point-wise multiplication of two vectors. + + + + + Add two vectors, pointwise + + + + + Get the transpose of a vector. + + + + + + + + Gets the number of rows in a vector + + + + + Computes the 2-norm of a vector: sqrt(x.Transpose*x). + + + + + Gets the number of entries in a vector + + + + + Gets an item from a vector + + + + + Get the underlying internal array of values for a vector. This property + should only be used when interoperating with other matrix libraries. + + + + + Gets the element operations for the element type of a vector, if any + + + + + Return a new array containing a copy of the elements of a vector + + + + + Supports the slicing syntax 'v.[idx1..idx2] <- v2' + + + + + Permute the elements of a vector. + + + + + Supports the slicing syntax 'v.[idx1..idx2]' + + + + + + + + + + + Create a new matrix that is a copy of a array + + + + + The type of column vectors. The arithmetic operations on the element type are determined by inspection + on the element type itself + + + + + + + + The type of complex numbers + + + + + The type of floating point matrices + + + + + + + + The type of floating point row vectors + + + + + The type of floating point column vectors + + + + + Tagent + + + + + Cosine + + + + + Sine + + + + + sqrt(x) and 0 <= phase(x) < pi + + + + + log(x) is natural log (base e) + + + + + exp(x) = e^x + + + + + pi + + + + + Multiply a complex number by a scalar + + + + + Multiply a scalar by a complex number + + + + + Unary negation of a complex number + + + + + Complex division of two complex numbers + + + + + Multiply two complex numbers + + + + + Subtract one complex number from another + + + + + Add two complex numbers + + + + + The complex number 0+1i + + + + + The complex number 1+0i + + + + + The complex number 0+0i + + + + + The conjugate of a complex number, i.e. x-yi + + + + + A complex of magnitude 1 and the given phase and , i.e. cis x = mkPolar 1.0 x + + + + + Create a complex number using magnitude/phase polar coordinates + + + + + The imaginary part of a complex number + + + + + The real part of a complex number + + + + + The polar-coordinate phase of a complex number + + + + + The polar-coordinate magnitude of a complex number + + + + + + + + + + + Constructs a complex number from both the real and imaginary part. + + + + + + + + Record an AppDomain-wide association between the given type and the given dictionary of + numeric operations. Raise an error if an existing association already exists. + + + + + + + + Attempt to determine a numeric association for the given type, i.e. a registered dictionary of + numeric operations. The interface can be queried dynamically for additional functionality in the numerics + hierarchy. + + + + + Associations are a way of associating dictionaries of + operations with given types at runtime. Associations are global to a + .NET application domain. Once specified an association may not be deleted + or modified. + + In this release the system of associations is simply + limited to a registry of types that support dictionaries (i.e. interface objects) + of numeric operations. The following types are pre-registered with associated numeric + operations: float, int32, int64, bigint, float32, Complex, bignum. Other types must be + registered explicitly by user code. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + In-place subtraction, mutating the first matrix argument. + + + + + In-place addition, mutating the first matrix argument. + + + + + Create a new matrix that is a copy of the given array + + + + + Map the given indexed function over each element of a matrix, producing a new matrix + + + + + Map a function over each element of a matrix, producing a new matrix + + + + + Fold a function down a particular row of a matrix + + + + + Fold a function along a particular column of a matrix + + + + + Fold a function along each row of a matrix + + + + + Fold a function down each column of a matrix + + + + + Fold an indexed function over all elements of a matrix + + + + + Fold a function over all elements of a matrix + + + + + Check if a predicate holds for at least one element of a matrix + + + + + Check if a predicate holds for all elements of a matrix + + + + + Check if a predicate holds for at least one element of a matrix + + + + + Check if a predicate holds for all elements of a matrix + + + + +sqrt(sum(x*x)) of all the elements of a matrix + + + + +Multiply all the elements of a matrix + + + + + Sum all the elements of a matrix + + + + + Generate a new matrix of the same size as the input with random entries + drawn from the range 0..aij. Random numbers are generated using a globally + shared System.Random instance with the initial seed 99. + + + + + Sum of the diagonal elements of a matrix + + + + + Transpose of a matrix. Use also m.Transpose + + + + + Point-wise exponential of a matrix. + + + + + Dot product + + + + + Add two matrices (operator +) + + + + + Point-wise minimum element of two matrices + + + + + Point-wise maximum element of two matrices + + + + + Ensure that a matrix uses dense representation + + + + + Return the first column of a matrix + + + + + Return the first row of a matrix + + + + + Return the element at row 0, column 0 of a matrix + + + + + Create a matrix with one column from the given vector + + + + + Create a matrix with one row from the given row vector + + + + + Create a 1x1 matrix containing the given value + + + + + Return a new array containing the elements of the given matrix + + + + + Create a matrix from the given data + + + + + Create a matrix from the given data + + + + + Create a matrix from the given data + + + + + Create a square matrix with a vector lying on diagonal + + + + + Create a square matrix with the constant 1.0 lying on diagonal + + + + + Create a matrix with all entries zero + + + + + Create a sparse representation matrix with the given entries. Not all + operations are available for sparse matrices, and mutation is not permitted. + If an operation on sparse matrices raises a runtime exception then consider + converting to a dense matrix using to_dense. + + + + + Create a dense representation matrix with the given entries. + + + + + Create a matrix with all entries the given constant + + + + + + + + Set an element of a matrix + + + + + Get an element of a matrix + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Subtract the second matrix from the first, by mutating the first + + + + + Add the second matrix to the first by, mutating the first + + + + + Map the given position-indexed function over a matrix + + + + + Map a function over a matrix + + + + + Create a new matrix that is a copy of the given array + + + + + Return true if an indexed predicate returns true for some value in a matrix + + + + + Return true if an indexed predicate returns true for all values in a matrix + + + + + Return true if a predicate returns true for some value in a matrix + + + + + Return true if a predicate returns true for all values in a matrix + + + + + Fold an indexed function over all elements of a matrix + + + + + Fold a function over all elements of a matrix + + + + + Returns sqrt(sum(norm(x)*(norm(x))) of all the elements of a matrix. + The element type of a matrix must have an associated instance of INormFloat<'T> (see <c>GlobalAssociations</c>) ((else NotSupportedException)). + + + + + Compute the product of the elements in a matrix + + + + + Compute the sum of the elements in a matrix + + + + + Compute the sum of the diagonal of a square matrix + + + + + Return a new matrix which is the transpose of the input matrix + + + + + Sum of the point-wise multiple of the two matrices. + The element type of a matrix must have an associated instance of INumeric<'T> (see <c>GlobalAssociations</c>) ((else NotSupportedException)). + + + + +Take the pointwise maximum of two matrices + + + + +Take the pointwise maximum of two matrices + + + + + Create a matrix containing the given vector along the diagonal. + The element type of a matrix must have an associated instance of INumeric<'T> (see <c>GlobalAssociations</c>) ((else NotSupportedException)). + + + + + Create a square matrix with the one for the element type lying on diagonal + The element type of a matrix must have an associated instance of INumeric<'T> (see <c>GlobalAssociations</c>) ((else NotSupportedException)). + + + + + Create a matrix containing the zero element at each index. + The element type of a matrix must have an associated instance of INumeric<'T> (see <c>GlobalAssociations</c>) ((else NotSupportedException)). + + + + + Create a matrix using a function to compute the item at each index. + The element type of a matrix must have an associated instance of INumeric<'T> (see <c>GlobalAssociations</c>) ((else NotSupportedException)). + The function is passed the dictionary of associated operations in addition to the index pair. + + + + + Create a matrix using a function to compute the item at each index. + + + + + Extract the first column of a matrix + + + + + Extract the first row of a matrix + + + + + Get the element at column zero, row zero + + + + + Create a matrix from a column vector + + + + + Create a matrix from a row vector + + + + + Create a 1x1 matrix containing the given value + + + + + Create a sparse matrix from the given sequence of elements + + + + + Create a dense matrix from the given sequence of elements + + + + + Create a matrix containing the given value at every element. + + + + + Return a new array containing the elements of the given matrix + + + + + Create a matrix from the given data + + + + + Create a matrix from the given data + + + + + Create a matrix from the given data + + + + + Set an element in a matrix. The indexes are given in row/column order. + + + + + Get an element from a matrix. The indexes are given in row/column order. + + + + + Operations to manipulate matrix types carrying + arbitrary element types. The names and types of the operations match those + in the containing module Math.Matrix. + + The numeric operations on the element type (add, zero etc.) are inferred from the type + argument itself. That is, for some operations + the element type of a matrix must have an associated instance of INumeric<'T> + or some more specific numeric association (see <c>GlobalAssociations</c>) ((else NotSupportedException)). + + + + + Operations to manipulate floating + point matrices. The submodule <c>Matrix.Generic</c> contains a + matching set of operations to manipulate matrix types carrying + arbitrary element types. + + + + + Builds a (row) vector from a sequence of floats. + + + + + Builds a (column) vector from a sequence of floats. + + + + + Builds a matrix from a sequence of sequence of floats. + + + + + + + Version of System.Single.NaN that is generic in its units-of-measure + + + Version of System.Single.PositiveInfinity that is generic in its units-of-measure + + + Version of System.Double.NaN that is generic in its units-of-measure + + + Version of System.Double.PositiveInfinity that is generic in its units-of-measure + + + + + + + + + + + + + + + + + + + + + + + + + + + + The identity permutation over any size + + + + + Return a permutation that rotates right by the given distance. If the distance + is negative then a left rotation results. + + + + + Return a permutation that, when applied, maps index 0 to size-1, size-1 to 0 etc. + + + + + Return a swaps the given two elements over any size + + + + + + + + Create a permutation by specifying (source,destination) index pairs. For example, + Permutation(3,[ (0,2);(1,0); (2,1) ]) specifies a permutation that rotates + all elements left one place. Not all elements need be given, e.g. + Permutation(5,[ (1,2);(2,1) |]) specifies a permutation that swaps elements at indexes + 1 and 2. + + + + + + + + Create a permutation by specifying the result of permuting [| 0 .. n-1 |]. For example, + Permutation.ofArray [| 1;2;0 |] specifies a permutation that rotates all elements right one place. + + + + + + + + Unified atomic mass unit + + + + + Electron volt + + + + + Stefan-Boltzmann constant + + + + + Boltzmann constant R/N_A + + + + + Molar gas constant + + + + + Faraday constant + + + + + Avogadro constant + + + + + Rydberg constant + + + + + Fine-structure constant + + + + + Proton mass + + + + + Electron mass + + + + + Conductance quantum 2e^2/h + + + + + Magnetic flux quantum h/2e + + + + + Elementary charge + + + + + Dirac constant, also known as the reduced Planck constant = h/2pi + + + + + Planck constant + + + + + Newtonian constant of gravitation + + + + + electric constant = 1/(mu0 c^2) + + + + + magnetic constant + + + + + speed of light in vacuum + + + + + Fundamental physical constants, with units-of-measure + + + + + + + + + + + + + + + + + Return a new array containing a copy of the elements of the given vector + + + + + Create a vector from an array of double precision floats + + + + + Create a vector from a sequence of numbers + + + + + Create a vector from a list of numbers + + + + + + + + + + + Return a vector of the given length where every entry is zero. + + + + + Create by comprehension + + + + + Create by constant initialization + + + + + Get the dimensions (number of rows) of a column rowvec. + + + + + Set an element of a column rowvec + + + + + Get an element of a column vector + + + + + + + + + + + + + + + + + + + + Return a new array containing a copy of the elements of the given vector + + + + + Create a row vector from an array of elements + + + + + Create a row vector from a sequence of elements + + + + + Create a row vector from a list of elements + + + + + Return a vector of the given length where every entry is zero. + + + + + Create by constant initialization + + + + + Create by comprehension + + + + + Transpose the row vector + + + + + Get the number of rows in a column vector. + + + + + Set an element in a column vector. + + + + + Get an element from a column vector. + + + + + Operations to manipulate row vectors types carrying + arbitrary element types. + + + + + Operations to manipulate floating + point row vectors. These are included for completeness and are + nearly always transposed to column vectors. + + + + + katal, SI unit of catalytic activity + + + + + sievert, SI unit of does equivalent + + + + + gray, SI unit of absorbed dose + + + + + becquerel, SI unit of activity referred to a radionuclide + + + + + lux, SI unit of illuminance + + + + + lumen, SI unit of luminous flux + + + + + henry, SI unit of inductance + + + + + tesla, SI unit of magnetic flux density + + + + + weber, SI unit of magnetic flux + + + + + siemens, SI unit of electric conductance + + + + + ohm, SI unit of electric resistance + + + + + farad, SI unit of capacitance + + + + + volt, SI unit of electric potential difference, electromotive force + + + + + coulomb, SI unit of electric charge, amount of electricity + + + + + watt, SI unit of power, radiant flux + + + + + joule, SI unit of energy, work, amount of heat + + + + + pascal, SI unit of pressure, stress + + + + + newton, SI unit of force + + + + + hertz, SI unit of frequency + + + + + candela, SI unit of luminous intensity + + + + + mole, SI unit of amount of substance + + + + + kelvin, SI unit of thermodynamic temperature + + + + + ampere, SI unit of electric current + + + + + second, SI unit of time + + + + + kilogram, SI unit of mass + + + + + metre (or meter), SI unit of length + + + + + The International System of Units (SI) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Map an indexed function over each element of a vector + + + + + Map a function over each element of a vector + + + + + Copy a vector + + + + + Fold an indexed function over all elements of a vector + + + + + Fold a function over all elements of a vector + + + + + Return true if an indexed predicate returns true for some value in a vector + + + + + Return true if an indexed predicate returns true for all values in a vector + + + + + Return true if a predicate returns true for some value in a vector + + + + + Return true if a predicate returns true for all values in a vector + + + + + Computes the 2-norm of a vector: sqrt(x.Transpose*x). + + + + +Multiply all the elements of a matrix + + + + +Sum all the elements of a vector + + + + +Transpose of a matrix. Use also m.Transpose + + + + +Point-wise exponential of a vector. + + + + +Dot product + + + + + Create a vector that represents a integral mesh over the given range + e.g. range 1 5 = vector [ 1.;2.;3.;4.;5. ] + + + + + Create a vector that represents a mesh over the given range + e.g. rangef (-1.0) 0.5 1.0 = vector [ -1.0; -0.5; 0.0; 0.5; 1.0] + + + + + Return a vector of the given length where every entry is zero. + + + + + Generate a vector of the given length where each entry contains the given value + + + + + Create a 1-element vector + + + + + Return a new array containing a copy of the elements of the given vector + + + + + Create a vector from an array of double precision floats + + + + + Create a vector from a sequence of numbers + + + + + Create a vector from a list of numbers + + + + + Create a vector of a fixed length using a function to compute the initial element values + + + + + Get the dimensions (number of rows) of a column vector. Identical to <c>nrows</c> + + + + + Set an element of a column vector + + + + + Get an element of a column vector + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Map an indexed function over each element of a vector + + + + + Map a function over each element of a vector + + + + + Copy the vector + + + + + Fold an indexed function over all elements of a vector + + + + + Fold a function over all elements of a vector + + + + + Return true if an indexed predicate returns true for some value in a vector + + + + + Return true if an indexed predicate returns true for all values in a vector + + + + + Return true if a predicate returns true for some value in a vector + + + + + Return true if a predicate returns true for all values in a vector + + + + + Computes the 2-norm of a vector: sqrt(x.Transpose*x). + + + + +Multiply all the elements of a matrix + + + + +Sum all the elements of a vector + + + + +Dot product + + + + +Take the pointwise minimum of two vectors + + + + +Take the pointwise maximum of two vectors + + + + + Return a vector of the given length where every entry is zero. + + + + + Generate a vector of the given length where each entry contains the given value + + + + + Return a new array containing a copy of the elements of the given vector + + + + + Create a vector from an array of elements + + + + + Create a 1-element vector + + + + + Create a vector from a sequence of numbers + + + + + Create a vector from a list of numbers + + + + + Creation: useful when the element type has associated operations. + + + + + Creation: general + + + + + Get the dimensions (number of rows) of a column vector. Identical to <c>nrows</c> + + + + + Set an element of a column vector + + + + + Get an element of a column vector + + + + + Operations to manipulate column vectors carrying + arbitrary element types. + + + + + Operations to manipulate floating + point column vectors. The submodule VectorOps.Generic contains a + matching set of operations to manipulate column vectors carrying + arbitrary element types. + + + + + See NativeArray2 + + + + + Get or set an entry in the array + + + + + + + + + + + + + + View a FortranMatrix as a CMatrix. Doesn't actually allocate + a new matirx - just gives a different label to the same bits, and swaps the + row/column count information associated with the bits. + + + + + Get or set an entry in the array + + + + + + + + This type wraps a pointer to a blob of unmanaged memory assumed to contain + a Fortran-style column major two-dimensional matrix of items compatible with the (presumably blittable) + type 'T. The blob of memory must be allocated and managed externally, + e.g. by a computation routine written in C. + + All operations on this type are marked inlined + because the code used to implement the operations is not verifiable. + + Any code that uses these operations will be unverifiable and may + cause memory corruption if not used with extreme care. + + + + + Get or set an entry in the array + + + + + Pointer to the C-style row major two-dimensional array + + + + + Get the number of rows of the native array + + + + + Get the number of columns of the native array + + + + + View a CMatrix as a FortranMatrix. Doesn't actually allocate + a new matirx - just gives a different label to the same bits, and swaps the + row/column count information associated with the bits. + + + + + Get or set an entry in the array + + + + + Creates a C-style row major two-dimensional array from a native pointer, the number of rows and the number of columns. + Nothing is actually copied. + + + + + This type wraps a pointer to a blob of unmanaged memory assumed to contain + a C-style row major two-dimensional matrix of items compatible with the (presumably blittable) + type 'T. The blob of memory must be allocated and managed externally, + e.g. by a computation routine written in C. + + All operations on this type are marked inlined + because the code used to implement the operations is not verifiable. + + Any code that uses these operations will be unverifiable and may + cause memory corruption if not used with extreme care. + + + + + Get or set an entry in the array + + + + + Pointer to the C-style one-dimensional array + + + + + Length of the C-style one-dimensional array + + + + + Get or set an entry in the array + + + + + Creates a C-style one dimensional array from a native pointer and the length of the array + Nothing is actually copied. + + + + + This type wraps a pointer to a blob of unmanaged memory assumed to contain + a C-style one-dimensional array of items compatible with the (presumably blittable) + type 'T. The blob of memory must be allocated and managed externally, + e.g. by a computation routine written in C. + + All operations on this type are marked inlined + because the code used to implement the operations is not verifiable. + + Any code that uses these operations will be unverifiable and may + cause memory corruption if not used with extreme care. + + + + + For native interop. Pin the given object + + + + + For native interop. Pin the given object + + + + + + + + + + + + + + + + + + + + + + + Represents a pinned handle to a structure with an underlying 2D array, i.e. an underlying NativeArray2. + Used when interfacing with native code math libraries such as LAPACK. + + + + + For native interop. Pin the given object + + + + + + + + + + + + + + + + + + + + Represents a pinned handle to a structure with an underlying 1D array, i.e. an underlying NativeArray. + Used when interfacing with native code math libraries such as LAPACK. + + + + + + + + Pin the given ref for the duration of a single call to the given function. A native pointer to + the contents of the ref is passed to the given function. Cleanup the GCHandle associated with the + pin when the function completes, even if an exception is raised. + + + + + + + + Return the name of the argument + + + + + Return the usage help associated with the argument + + + + + Return the argument type and action of the argument + + + + + + + + + + + Prints the help for each argument. + + + + + Parse some of the arguments given by 'argv', starting at the given position + + + + + Parse the arguments given by System.Environment.GetEnvironmentVariables() + according to the argument processing specifications "specs". + Args begin with "-". Non-arguments are passed to "f" in + order. "use" is printed as part of the usage line if an error occurs. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + The spec value describes the action of the argument, + and whether it expects a following parameter. + + + + + Interpret tables for a unicode lexer generated by fslex. + + + + + + + + Interpret tables for a unicode lexer generated by fslex, processing input asynchronously + + + + + The type of tables for an unicode lexer generated by fslex. + + + + + Interpret tables for an ascii lexer generated by fslex. + + + + + + + + Interpret tables for an ascii lexer generated by fslex, processing input asynchronously + + + + + The type of tables for an ascii lexer generated by fslex. + + + + + The start position for the lexeme + + + + + True if the refill of the buffer ever failed , or if explicitly set to true. + + + + + The end position for the lexeme + + + + + The start position for the lexeme + + + + + The length of the matched string + + + + + The matched string + + + + + True if the refill of the buffer ever failed , or if explicitly set to true. + + + + + The end position for the lexeme + + + + + Dynamically typed, non-lexically scoped parameter table + + + + + Fast helper to turn the matched characters into a string, avoiding an intermediate array + + + + + Fetch a particular character in the matched string + + + + + Create a lex buffer suitable for use with a Unicode lexer that reads character inputs from the given text reader + + + + + Create a lex buffer suitable for Unicode lexing that reads characters from the given string + + + + + Create a lex buffer that reads character or byte inputs by using the given function + + + + + Create a lex buffer suitable for Unicode lexing that reads characters from the given array + + + + + + + + Create a lex buffer suitable for byte lexing that reads characters from the given array + + + + + + + + Create a lex buffer suitable for use with ASCII byte lexing that reads byte inputs from the given binary reader + + + + + Create a lex buffer that asynchronously reads character or byte inputs by using the given function + + + + + Remove all input, though don't discard the current lexeme + + + + + Input buffers consumed by lexers generated by <c>fslex.exe </c> + + + + + The absolute offset of the column for the position + + + + + The absolute offset of the beginning of the line + + + + + The line number for the position + + + + + The file name for the position + + + + + Return absolute offset of the start of the line marked by the position + + + + + + + + The line number in the input stream, assuming fresh positions have been updated + using AsNewLinePos() and by modifying the EndPos property of the LexBuffer. + + + + + The file name associated with the input stream. + + + + + Get an arbitrary position, with the empty string as filename, and + + + + + Return the column number marked by the position, i.e. the difference between the AbsoluteOffset and the StartOfLineAbsoluteOffset + + + + + + + + The character number in the input stream + + + + + Gives a position shifted by specified number of characters + + + + + Get a position corresponding to the first line (line number 1) in a given file + + + + + Given a position at the start of a token of length n, return a position just beyond the end of the token + + + + + + + + Position information stored for lexing tokens + + + + + The tag of the error terminal + + + + + The total number of terminals + + + + + This function is used to hold the user specified "parse_error" or "parse_error_rich" functions + + + + + This table is logically part of the Goto table + + + + + The sparse table offsets for the productions active for each state + + + + + The sparse table for the productions active for each state + + + + + The sparse goto table row offsets + + + + + The sparse goto table + + + + + The immediate action table + + + + + The number of symbols for each reduction + + + + + The sparse action table row offsets + + + + + The sparse action table elements + + + + + A function to compute the data carried by a token + + + + + A function to compute the tag of a token + + + + + The token number indicating the end of input + + + + + The reduction table + + + + + Interpret the parser table taking input from the given lexer, using the given lex buffer, and the given start state. + Returns an object indicating the final synthesized value for the parse. + + + + + Tables generated by fsyacc + The type of the tables contained in a file produced by the fsyacc.exe parser generator. + + + + + The stack of state indexes active at the parse error + + + + + The token that would cause a shift at the parse error + + + + + The stack of productions that would be reduced at the parse error + + + + + The tokens that would cause a reduction at the parse error + + + + + The state active at the parse error + + + + + The message associated with the parse error + + + + + The token that caused the parse error + + + + + The context provided when a parse error occurs + + + + + Get the full range of positions matched by the production + + + + + Get the store of local values associated with this parser + + + + + Raise an error in this parse context + + + + + Get the start position for the terminal or non-terminal at a given index matched by the production + + + + + Get the start and end position for the terminal or non-terminal at a given index matched by the production + + + + + Get the end position for the terminal or non-terminal at a given index matched by the production + + + + + Get the value produced by the terminal or non-terminal at the given position + + + + + The information accessible via the <c>parseState</c> value within parser actions. + + + + + Indicates a parse error has occured and parse recovery is in progress + + + + + + + + Indicates an accept action has occured + + + + + The default implementation of the parse_error function + + + + + The default implementation of the parse_error_rich function + + + + + Helpers used by generated parsers. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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> + + + + + The maximum number of rows for which to generate layout for table-like + structures. -1 if no maximum. + + + + + The maximum number of elements for which to generate layout for + list-like structures, or columns in table-like + structures. -1 if no maximum. + + + + + Return to the layout-generation + environment to layout any otherwise uninterpreted object + + + + + + + + + + + + + + + + + Data representing structured layouts of terms. The representation + of this data type is only for the consumption of formatting engines. + + + + + + + + + + + + + + Data representing joints in structured layouts of terms. The representation + of this data type is only for the consumption of formatting engines. + + + + + 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. + + + + diff --git a/packages/FSPowerPack.Community.2.0.0.0/Lib/sl3/FSharp.PowerPack.Compatibility.dll b/packages/FSPowerPack.Community.2.0.0.0/Lib/sl3/FSharp.PowerPack.Compatibility.dll new file mode 100644 index 0000000000000000000000000000000000000000..d2dd8e9b62de8ee0ff9e54d944929f908251acfc Binary files /dev/null and b/packages/FSPowerPack.Community.2.0.0.0/Lib/sl3/FSharp.PowerPack.Compatibility.dll differ diff --git a/packages/FSPowerPack.Community.2.0.0.0/Lib/sl3/FSharp.PowerPack.dll b/packages/FSPowerPack.Community.2.0.0.0/Lib/sl3/FSharp.PowerPack.dll new file mode 100644 index 0000000000000000000000000000000000000000..af604938da570ad032553a66207e1008bb184f4a Binary files /dev/null and b/packages/FSPowerPack.Community.2.0.0.0/Lib/sl3/FSharp.PowerPack.dll differ diff --git a/packages/FSPowerPack.Community.2.0.0.0/Lib/sl4/FSharp.PowerPack.Compatibility.dll b/packages/FSPowerPack.Community.2.0.0.0/Lib/sl4/FSharp.PowerPack.Compatibility.dll new file mode 100644 index 0000000000000000000000000000000000000000..3d595e8005719d5e48639b1fcf1cd74286ec56a9 Binary files /dev/null and b/packages/FSPowerPack.Community.2.0.0.0/Lib/sl4/FSharp.PowerPack.Compatibility.dll differ diff --git a/packages/FSPowerPack.Community.2.0.0.0/Lib/sl4/FSharp.PowerPack.dll b/packages/FSPowerPack.Community.2.0.0.0/Lib/sl4/FSharp.PowerPack.dll new file mode 100644 index 0000000000000000000000000000000000000000..99347b6794a1d26e238bc76edbd7950418e8b4b8 Binary files /dev/null and b/packages/FSPowerPack.Community.2.0.0.0/Lib/sl4/FSharp.PowerPack.dll differ diff --git a/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.Compiler.CodeDom.dll b/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.Compiler.CodeDom.dll new file mode 100644 index 0000000000000000000000000000000000000000..b13986cf898c405c7c10512703a21b5552b27cd7 Binary files /dev/null and b/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.Compiler.CodeDom.dll differ diff --git a/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.Compiler.CodeDom.xml b/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.Compiler.CodeDom.xml new file mode 100644 index 0000000000000000000000000000000000000000..55a6f73b2377ba905113ea46fd4c31b432d76571 --- /dev/null +++ b/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.Compiler.CodeDom.xml @@ -0,0 +1,755 @@ + + +FSharp.Compiler.CodeDom + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Convert string into Option string where null and String.Empty result in None + + + + + + + + + + + + + + Implementation of the CodeDomProvider for the F# language. + This is specialized version that can be used with ASP.NET. + + + + + + + + Implementation of the CodeDomProvider for the F# language. + If you intend to use CodeDom with ASP.NET you should use <c>FSharpAspNetCodeProvider</c> instead. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Where are we generating member? + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + We use exception for returning value when generating complex + code that returns using imperative "return" statement + + + + + Type of the method + + + + + Types of all local variables in the method + + + + + Names of all type arguments in scope (need to rename T -> 'T etc.) + + + + + + + + Options, output, ... + + + + + Some unique ID for every namespace (so we don't have name clashes) + + + + + + + + Hacking for ASP.NET incorrect array initializers + They generate "string" where codedom test suite uses "string[]" + + + + + Reference inherited fields using "fld" instead of "this.fld" + (could be used in the future to allow implicit classes in ASP.NET?) + + + + + No extra configuration + + + + + + + + + + + + + + Generate code for compile unit (file) + + + + + Generate code for type declaration (not included in namespace) + + + + + Generate code for namespace without compilation unit + + + + + Generates namespace code - takes output from 'preprocessNamespace' + + + + + + + + Returns CodeNamespace, list of classes with scope (which includes class names + of containing classes and sequence of class renames) + + + + + Generates a main method. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Generates method code + Generates comments and than calls 'generatMethod' + + + + + By default all CodeDOM generated methods are 'virtual' which means that + we have to generate "abstract and default" (unless we're in struct or + we're implementing an interface, or the method is overriden) + (NOTE: the same logic isn't properly implemented for properties) + + + + + Abstract method in the interface + + + + + + + + + + + Abstract property in the interface + + + + + fields + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Generate expression - with unkonw type + + + + + Matches array or indexer expression and corrects it if the generated CodeDOM is incorrect + + + + + Generates a "this" or "CurrentType" reference depending on whether a reference + is static or not. Used for "ambiguous" references without a type or object qualifier. + + Unfortunately the Code tree isn't so kind as to tell us whether a reference is static + or not up front. Instead we predetermine a set of some static members and + assume all other references are instance references. + + + + + + Tries to resolve type of an expression using a few tricks: + * Fields of current type may have known type + * Properties of current type as well + * We can also try to resolve other properties (sometimes it helps) + * Resolve type for local variables or argument reference + + + + + Tries to resolve if type is an array, so we can generate + appropriate code (it can be either indexer or array, but we need to generate + .Item call for indexers (no overloading is supported by .[]). + Returns: "None" - can't resolve, "Some" resovled (true/false - is it an array?) + + + + + Generate array initializer. Checks generator options for ASP.NET workaround. + + + + + Generate value of primitive expression + + + + + Returns F# conversion function for the specified type (or empty string) + + + + + Are both types numerical types where numeric conversion function can be applied? + + + + + Generates code for binary operator using function for left and right operand + + + + + Preprocess collection with type parameters + Returns array to be used with <c>usingTyParams</c> and + function to be called to generate < ... > code + + + + + Record specified type parameters in the context, call generating function + and then restore the original type parameters + (this works if someone uses nested type parameters with the same name) + + + + + Generate type arguments using context + + + + + Generate type reference using context + (this is most commonly used method) + + + + + Get type reference, but don't rename .NET types to F# types + (this is only needed when calling static methods on the type) + + + + + Get full type reference string using empty context + + + + + Get full type reference using information from context + + + + + Generate type reference with empty context + + + + + Generates type reference (not for arrays) + + + + + + + + + + + Tries to resolve type of a variable and adds it to the Context dictionary + + + + + Get System.Type of know type (either standard type or resolved) + + + + + + + + Output string as a valid F# identifier + + + + + + + + + + + + + + + + + Tries to find .NET type for specified type name + This is used when we need to know type in order to generate something correctly, + but it's just a fallback case + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Call specified function only on elements of specified type. + (performs dynamic type test using x.GetType()) + + + + + Process collection - keeps context through the whole processing + calls 'f' for every element in sequence and 'fs' between every two elements + as a separator. This is a variant that works on typed collections. + + + + + Process collection - keeps context through the whole processing + calls 'f' for every element in sequence and 'fs' between every two elements + as a separator + + + + + Perform map and filter operations in one + + + + + Create closure to do the counting + (this is usend when we need indexing during collection processing) + + + + + Print object converted to string + + + + + Identity function + + + + + Call function, but give it context as an argument + + + + + Append specified string without line-break + + + + + Break-line and append specified string + + + + + Print unique id using: "+> uniqid" + + + + + Function composition operator + + + + + Create context using specified text writer and options + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Walks through the CodeDom tree and keeps current "scope" and the result. + The result is collected through entire tree, but the modified scope is + passed only to sub-nodes of the current node. + + First argument is a function that is called for nodes and has a + function as a first argument, scope and result as a second and current node as a third. + The function argument can be used to walk deeper in the tree if wanted. + + + + + Search for members and return flat list of selected members + Function given as an argument returns tuple - first item specifies + if the current element should be included in the result, the second + specifies if we should walk through child members of the current object + + + + + + + + + + + + + + + + + + + diff --git a/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.PowerPack.Build.Tasks.dll b/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.PowerPack.Build.Tasks.dll new file mode 100644 index 0000000000000000000000000000000000000000..3cd9e1dbb7277425b510a1a8598792f5657c3278 Binary files /dev/null and b/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.PowerPack.Build.Tasks.dll differ diff --git a/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.PowerPack.Build.Tasks.xml b/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.PowerPack.Build.Tasks.xml new file mode 100644 index 0000000000000000000000000000000000000000..9102a4d667333689b3236b29db709f32b9b4ad2d --- /dev/null +++ b/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.PowerPack.Build.Tasks.xml @@ -0,0 +1,170 @@ + + +FSharp.PowerPack.Build.Tasks + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Convert string into Option string where null and String.Empty result in None + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.PowerPack.Compatibility.dll b/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.PowerPack.Compatibility.dll new file mode 100644 index 0000000000000000000000000000000000000000..a425ae0f3d7f14214364bdc044403d935406a7a6 Binary files /dev/null and b/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.PowerPack.Compatibility.dll differ diff --git a/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.PowerPack.Compatibility.xml b/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.PowerPack.Compatibility.xml new file mode 100644 index 0000000000000000000000000000000000000000..4fb8fe3e77548cc18c3dadd3eb0e0f7e5cc6565d --- /dev/null +++ b/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.PowerPack.Compatibility.xml @@ -0,0 +1,3203 @@ + + +FSharp.PowerPack.Compatibility + + + + + + + The spec value describes the action of the argument, + and whether it expects a following parameter. + + + + + + + + "usage specs use" prints the help for each argument. + + + + + "parse specs f use" parses the arguments given by Sys.argv + according to the argument processing specifications "specs". + Arguments begin with "-". Non-arguments are passed to "f" in + order. "use" is printed as part of the usage line if an error occurs. + + Permitted arguments are specified using triples: (arg, action, help). + Actions are: + Unit(f): call f, no subseq. arg + Set(br): set ref to 'true', no subseq. arg. + Clear(br): set ref to 'false, no subseq. arg. + String(f): pass the subseq. arg to f + Int(f): pass the subseq. arg to f + Float(f): pass the subseq. arg to f + Rest(f): pass all subseq. args to f in order + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + A simple command-line argument processor. + + + + + + + + As for Array2D.pin, except that the caller is responsible for calling Free on the returned GCHandle in order + to release the pin. + + + + + Pin the given array for the duration of a single call to the given function. A native pointer to + the first element in the array is passed to the given function. Cleanup the GCHandle associated with the + pin when the function completes, even if an exception is raised. + + + + + + + + + + + + + + Apply a function to each element of the array, threading an accumulator argument + through the computation. If the input function is <c>f</c> and the elements are <c>i0...iN</c> + then computes <c>f i0 (...(f iN s))</c> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Create a jagged 2 dimensional array. Synonym for createJaggedMatrix. + + + + + As for Array.pin, except that the caller is responsible for calling Free on the returned GCHandle in order + to release the pin. + + + + + Pin the given array for the duration of a single call to the given function. A native pointer to + the first element in the array is passed to the given function. Cleanup the GCHandle associated with the + pin when the function completes, even if an exception is raised. + + + + + Like reduceBack, but return both the intermediary and final results + + + + + Like reduce, but return both the intermediary and final results + + + + + Is an element in the array, uses (=) equality. + + + + + Create a jagged 2 dimensional array. + + + + + Compatibility operations on arrays. + + + + + + + + Read the given number of bytes as ASCII and add the resulting string + to the buffer. Warning: this assumes an ASCII encoding for the I/O channel, i.e. it uses + Pervasives.really_input and then use ascii_to_string to produce the string + to add. + + + + + Clears the buffer (same as Buffer.clear). + + + + + + + + Number of characters in the buffer. + + + + + Create a buffer with suggested size. + + + + + Gets the string built from the buffer. + + + + + Clears the buffer. + + + + + Given a string, start position and length add that substring to the buffer. + + + + + Add string to the buffer. + + + + + Add character to the buffer. + + + + + Add second buffer to the first. + + + + + Imperative buffers for building strings, a shallow interface to <c>System.Text.StringBuilder</c> + + + + + Converts a byte to a string + + + + + Converts a string to a byte + + + + + Converts a byte to an unsigned 32-bit integer + + + + + Converts an unsigned 32-bit integer to a byte + + + + + Converts a byte to a 16-bit integer + + + + + Converts a 16-bit integer to a byte + + + + + Converts a byte to a 32-bit integer + + + + + Converts a 32-bit integer to a byte + + + + + Converts a byte to a 32-bit integer + + + + + Converts a 32-bit integer to a byte + + + + + Converts a byte to a char + + + + + Converts a char to a byte + + + + + Shifts the binary representation a by n bits to the right + + + + + Shifts the binary representation a by n bits to the left + + + + + Combines the binary representation of a and b by bitwise xor + + + + + Combines the binary representation of a and b by bitwise or + + + + + Returns the bitwise logical negation of a + + + + + Combines the binary representation of a and b by bitwise and + + + + + Compares a and b and returns 1 if a > b, -1 if b < a and 0 if a = b + + + + + Returns the remainder of a divided by b + + + + + Returns a minus b + + + + + Returns a multiplied by b + + + + + Returns a divided by b + + + + + Returns the sum of a and b + + + + + Returns the predeccessor of the argument wrapped around 0uy + + + + + Returns the successor of the argument wrapped around 255uy + + + + + The value one as a System.Byte + + + + + The value zero as a System.Byte + + + + + Byte (8-bit) operations. + + + + + Converts the value of a Unicode character to its uppercase equivalent + + + + + Converts the value of a Unicode character to its lowercase equivalent + + + + + Compares a and b and returns 1 if a > b, -1 if b < a and 0 if a = b + + + + + Converts the value of the specified Unicode character to the equivalent 32-bit signed integer + + + + + Converts the value of the specified 32-bit signed integer to its equivalent Unicode character + + + + + Unicode characters, i.e. the <c>System.Char</c> type. see also the operations + in <c>System.Char</c> and the <c>System.Text.Encoding</c> interfaces if necessary. + + + + + "temp_file f s" returns a hitherto unused new file name. "f" and "s" + are hints as to a suitable file name and suffix for the file. + + + + + "quote s" is designed for use to quote a filename when using it + for a system command. It returns ("\'" ^ s ^ "\'"). + + + + + Returns true if the path is relative to the current directory but does not begin with + an explicit "." or ".." + + + + + Is the path is relative to the current directory or absolute. + + + + + Return true if the filename has a "." extension + + + + + "parent_dir_name" returns the name for the directory above the current directory on + this OS. + + + + + The name used for the current directory on this OS. + + + + + "dirname" and "basename" decompose a filename into a directory name + and a filename, i.e. "concat (dirname s) (basename s) = s" + + + + + "dirname" and "basename" decompose a filename into a directory name + and a filename, i.e. "concat (dirname s) (basename s) = s" + + + + + "concat a b" returns System.IO.Path.Combine(a,b), i.e. the + two names conjoined by the appropriate directory separator character + for this architecture. + + + + + Assuming "check_suffix f s" holds, "chop_suffix f s" returns the + filename "f" with the suffix "s" removed. + + + + + "chop_extension f" removes the extension from the given + filename. Raises ArgumentException if no extension is present. + + + + + "check_suffix f s" returns true if filename "f" ends in suffix "s", + e.g. check_suffix "abc.fs" ".fs" returns true. + + + + + Common filename operations. This module is included to make it possible to cross-compile + code with other ML compilers. See also <c>System.IO.Path</c> + + + + + Converts a 64-bit float to raw 64-bit representation + + + + + Converts a raw 64-bit representation to a 64-bit float + + + + + Converts a 64-bit float to a string + + + + + Converts a string to a 64-bit float + + + + + Converts a 64-bit float to a 32-bit float + + + + + Converts a 32-bit float to a 64-bit float + + + + + Converts a 64-bit float to a 64-bit integer + + + + + Converts a 64-bit integer to a 64-bit float + + + + + Converts a 64-bit float to a 32-bit integer + + + + + Converts a 32-bit integer to a 64-bit float + + + + + Converts a 64-bit float to a 32-bit integer + + + + + Converts a 32-bit integer to a 64-bit float + + + + + Compares a and b and returns 1 if a > b, -1 if b < a and 0 if a = b + + + + + Returns a minus b + + + + + Returns -a + + + + + Returns a multiplied by b + + + + + Returns a divided by b + + + + + Returns the sum of a and b + + + + + ML-like operations on 64-bit System.Double floating point numbers. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +A collection of operations for creating and using hash tables based on particular type-tracked hash/equality functions. +Generated by the Hashtbl.Make and Hashtbl.MakeTagged functors. This type is for use when you wish to +specify a comparison function once and carry around an object that is a provider of (i.e. a factory for) hashtables +that utilize that comparison function. + +The 'Tag' type parameter is used to track information about the comparison function, which helps ensure +that you don't mixup maps created with different comparison functions + + + + + OCaml compatible type name, for use when not opening module, e.g. Hashtbl.t + + + + + Build a collection of operations for creating and using + hashtables based on the given hash/equality functions. This returns a record + that contains the functions you use to create and manipulate tables of + this kind. The returned value is much like an ML module. You should call Make once for + each new pair of key/value types. You may need to constrain the result + to be an instantiation of Provider. + + let MyStringHashProvider : Provider<string,int> = Hashtbl.Make(myStringHash,myStringEq) + + + + + Same as Make, except track the comparison function being used through an additional type parameter. + + To use this function accurately you need to define a new named class that implements IEqualityComparer and + pass an instance of that class as the first argument. For example: + type MyHasher = + class + new() = { } + interface IEqualityComparer<string> with + member self.GetHashCode(x) = ... + member self.Equals(x,y) = ... + end + end + + let MyStringHashProvider : Hashtbl.Provider<string,int> = Hashtbl.MakeTagged(new MyStringHasher()) + + + + + Hash on the identity of an object. + + + + + Hash on the structure of a value according to the F# structural hashing + conventions + + + + + Lookup the key's data in the table + + + + + Replace the latest binding for the given key + + + + + Remove the latest binding for the given key + + + + + Test for the existence of any bindings for the given key + + + + +Apply the given function to each binding in the hash table + + + + + Fold over all bindings + + + + + Return all bindings for the given key + + + + + Lookup key's data in the table. + Raises exception is key not in table, if this could happen you should be using tryFind. + + + + + Create a copy of the table. Remember they are imperative and get mutated. + + + + + Empty the table. + + + + + Create hash table using the given data + + + + + Create a hash table using the given data + + + + + Add key and data to the table. + + + + + Create a hash table with the suggested initial size. + + Inlined to enable generation of efficient hash routines for the key type in the common case. + + + + + Multi-entry hash tables using the structural "hash" and "equals" functions. + +These tables can be used with keys of any type, but you should check that +structural hashing and equality are correct for your key type. +Structural hashing is efficient but not a suitable choice in all circumstances, +e.g. may not hash efficiently on non-reference types and deeply-structured types. +Better efficiency is typically achieved if key types are F#-generated +types. + +These hash tables may map items to multiple keys (see find_all). + +The implementations are not safe for concurrent reading/writing, +and so users of these tables should take an appropriate lock +before reading/writing if used in a concurrent setting. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Converts a 32-bit float to a raw 32-bit representation + + + + + Converts a raw 32-bit representation to a 32-bit float + + + + + Converts a 64-bit float to a raw 32-bit representation + + + + + Converts a raw 32-bit representation to a 64-bit float + + + + + Converts a 32-bit integer to a string + + + + + Converts a string to a 32-bit integer + + + + + Converts a 32-bit unsigned integer to a 32-bit integer + + + + + Converts a 32-bit unsigned integer to a 32-bit integer + + + + + Converts a 32-bit unsigned integer to a 64-bit integer + + + + + Converts a 64-bit unsigned integer to a 32-bit integer + + + + + Converts a 32-bit integer to a 32-bit unsigned integer + + + + + Converts a 32-bit unsigned integer to a 32-bit integer + + + + + Converts a 32-bit integer to a 32-bit integer (included for ML compatability) + + + + + Converts a 32-bit integer to a 32-bit integer (included for ML compatability) + + + + + Converts a 32-bit integer to a 32-bit float + + + + + Converts a 32-bit float to a 32-bit integer + + + + + Converts a 32-bit integer to a 64-bit float + + + + + Converts a 64-bit float to a 32-bit integer + + + + + Shifts the binary representation a by n bits to the right; high-order bits are zero-filled + + + + + Shifts the binary representation a by n bits to the right; high-order empty bits are set to the sign bit + + + + + Shifts the binary representation a by n bits to the left + + + + + Combines the binary representation of a and b by bitwise xor + + + + + Combines the binary representation of a and b by bitwise or + + + + + Returns the bitwise logical negation of a + + + + + Combines the binary representation of a and b by bitwise and + + + + + Compares a and b and returns 1 if a > b, -1 if b < a and 0 if a = b + + + + + Returns a minus b + + + + + Returns the remainder of a divided by b + + + + + Returns -a + + + + + Returns a multiplied by b + + + + + Returns a divided by b + + + + + Returns the sum of a and b + + + + + Returns the absolute value of the argument + + + + + Returns the successor of the argument + + + + + Returns the smallest 32-bit signed integer + + + + + Returns the largest 32-bit signed integer + + + + + Returns the predeccessor of the argument + + + + + The value minus one as a System.Int32 + + + + + The value one as a System.Int32 + + + + + The value zero as a System.Int32 + + + + + Basic operations on 32-bit integers. The type int32 is identical to <c>System.Int32</c>. + + + + + Converts a 64-bit float to a raw 64-bit representation + + + + + Converts a raw 64-bit representation to a 64-bit float + + + + + Converts a 64-bit integer to a string + + + + + Converts a string to a 64-bit integer + + + + + Converts a 64-bit integer to a native integer + + + + + Converts a native integer to a 64-bit integer + + + + + Converts a 64-bit integer to an unsigned 64-bit integer + + + + + Converts an unsigned 64-bit integer to a 64-bit integer + + + + + Converts a 64-bit integer to a 32-bit integer + + + + + Converts a 32-bit integer to a 64-bit integer + + + + + Converts a 64-bit integer to a 32-bit integer + + + + + Converts a 32-bit integer to a 64-bit integer + + + + + Converts a 64-bit integer to a 64-bit float + + + + + Converts a 64-bit float to a 64-bit integer + + + + + Converts a 64-bit integer to a 32-bit float + + + + + Converts a 32-bit float to a 64-bit integer + + + + + Shifts the binary representation a by n bits to the right; high-order bits are zero-filled + + + + + Shifts the binary representation a by n bits to the right; high-order empty bits are set to the sign bit + + + + + Shifts the binary representation a by n bits to the left + + + + + Combines the binary representation of a and b by bitwise xor + + + + + Combines the binary representation of a and b by bitwise or + + + + + Returns the bitwise logical negation of a + + + + + Combines the binary representation of a and b by bitwise and + + + + + Compares a and b and returns 1 if a > b, -1 if b < a and 0 if a = b + + + + + Returns a minus b + + + + + Returns the remainder of a divided by b + + + + + Returns -a + + + + + Returns a multiplied by b + + + + + Returns a divided by b + + + + + Returns the sum of a and b + + + + + Returns the absolute value of the argument + + + + + The value minus one as a System.Int64 + + + + + Returns the smallest 64-bit signed integer + + + + + Returns the largest 64-bit signed integer + + + + + Returns the successor of the argument + + + + + Returns the predeccessor of the argument + + + + + The value one as a System.Int64 + + + + + The value zero as a System.Int64 + + + + + Basic operations on 64-bit integers. The type int64 is identical to <c>System.Int64</c>. + + + + + + + + Build a lazy (delayed) value from the given computation + + + + + Check if a lazy (delayed) value has already been computed + + + + + Build a lazy (delayed) value from the given pre-computed value. + + + + + Build a lazy (delayed) value from the given computation + + + + + See Lazy.Force. + + + + + + + + ASCII LexBuffers + + The type "lexbuf" is opaque, but has an internal position information field + that can be updated by setting "lexbuf.EndPos", for example if you wish + to update the other fields in that position data before or during + lexing. You will need to do this if you wish to maintain accurate + line-count information. If you do this and wish to maintain strict + cross-compiling compatibility with OCamlLex and other tools you may need code + to conditionally use lexbuf_set_curr_p when compiling F# code. + + + + + + + + + + + + + + same as lexeme_end_p + + + + + Return absolute positions into the entire stream of characters + + + + + Return absolute positions into the entire stream of characters + + + + + Return the positions stored in the lexbuf for the matched string + + + + + Return the positions stored in the lexbuf for the matched string + + + + + Return a character from the matched string, innterpreting the bytes using an ASCII encoding + + + + + Return the bytes for the matched string + + + + + Return the matched string interpreting the bytes using the given Unicode text encoding + + + + + Return the matched string + + + + + Fuel a lexer from function that fills an array of bytes up to the given length, returning the + number of bytes filled. + + + + + Fuel a lexer from an array of bytes + + + + + Fuel a lexer from a string, converted to ascii using <c>System.Text.Encoding.ASCII.GetBytes</c> + + + + + Fuel a lexer using the given BinaryReader. + + + + + Fuel a lexer using the given TextReader or StreamReader. + The characters read are decoded to bytes using the given encoding (e.g. System.Text.Encoding.ASCII) + and the bytes presented to the lexer. The encoding used to decode the characters + is associated with the expectations of the lexer (e.g. a lexer may be constructed to accept only + ASCII or pseudo-UTF8 bytes) and will typically be different to + the encoding used to decode the file. + + + + + Fuel a lexer using the given in_channel. The bytes are read using Pervasives.input. + If the in_channel is a textual channel the bytes are + presented to the lexer by decoding the characters using System.Text.Encoding.ASCII. + + + + + Remove all input, though don't discard the except the current lexeme + + + + + Lexing: ML-like lexing support + + This file maintains rough compatibility for lexbuffers used by some ML + laxer generators. The lexbuf carries an associated pair of positions. + Beware that only the "cnum" (absolute character number) field is automatically + updated as each lexeme is matched. Upon each successful match the prior end + position is transferred to be the start position and a new start position + is allocated with an updated pos_cnum field. + + + + + Return the tail of the list. + + Raises <c>System.ArgumentException</c> if <c>list</c> is empty + + + + + Return the first element of the list. + + Raises <c>System.ArgumentException</c> if <c>list</c> is empty + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + "rev_append l1 l2" evaluates to "append (rev l1) l2" + + + + + "rev_map2 f l1 l2" evaluates to "map2 f (rev l1) (rev l2)" + + + + + "rev_map f l1" evaluates to "map f (rev l1)" + + + + + Return true if the list is not empty. + + + + + See <c>mem</c>, but uses the physical equality operator (==) for equality tests. + + + + + See <c>remove_assoc</c>, but uses the physical equality operator (==) for equality tests. + + + + + See <c>mem_assoc</c>, but uses the physical equality operator (==) for equality tests. + + + + + See <c>try_assoc</c>, but uses the physical equality operator (==) for equality tests. + + + + + See <c>assoc</c>, but uses the physical equality operator (==) for equality tests + + + + + Remove pair for key from the association list (if it's there). + + + + + Does the key have pair in the association list? + + + + + Lookup key's data in association list, uses (=) equality, + returning "Some data" or "None". + + + + + Lookup key's data in association list, uses (=) equality. + Raise <c>System.IndexOutOfRangeException</c> exception if key not found, in which case you should typically use <c>try_assoc</c> instead. + + + + + Is an element in the list. Elements are compared using generic equality. + + + + + Is an element in the list. Elements are compared using generic equality. + + + + + Like reduceBack, but return both the intermediary and final results + + + + + Like reduce, but return both the intermediary and final results + + + + + Compatibility operations on lists. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + A provider for creating and using maps based on a particular comparison function. + The 'Tag type parameter is used to track information about the comparison function. + + + + + A functor to build a collection of operations for creating and using + maps based on the given comparison function. This returns a record that + contains the functions you use to create and manipulate maps of + this kind. The returned value is much like an ML module. + + Language restrictions related to polymorphism may mean you + have to create a new instantiation of for each toplevel + key/value type pair. + + To use this function you need to define a new named class that implements IComparer and + pass an instance of that class as the first argument. For example: + type MyComparer = + new() = { } + interface IComparer<string> with + member self.Compare(x,y) = ... + + let MyStringMapProvider : Map.Provider < string,int > = Map.MakeTagged(new MyComparer()) + + + + + + + + + + + + + + Negation of Obj.eq (i.e. reference/physical inequality) + + + + + See Microsoft.FSharp.Core.LanguagePrimitives.PhysicalEquality + + + + + See Microsoft.FSharp.Core.Operators.box + + + + + See Microsoft.FSharp.Core.Operators.unbox + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + You can initialize error recovery by raising the Parse_error exception. + + + + + Parsing: parser support for parsers produced by fsyacc. + + Parsers generated by fsyacc provide location information within parser + actions. However that information is not available globally, but + rather is accessed via the functions available on the following local + variable which is available in all parser actions: + + parseState : 'a Microsoft.FSharp.Text.Parsing.IParseState + + However, this is not compatible with the parser specifications used + with ocamlyacc and similar tools, which make a single parser state available + globally. If you wish to use a global parser state (e.g. so your code will + cross-compile with OCaml) then you can use the functions in this file. + You will need to either generate the parser with '--ml-compatibility' option + or add the code + + Parsing.set_parse_state parseState; + + at the start of each action of your grammar. The functions below + simply report the results of corresponding calls to the latest object + specified by a call to set_parse_state. + + Note that there could be unprotected multi-threaded concurrent access for the + parser information, so you should not in general use these + functions if there may be more than one parser active, and + should instead use the functions directly available from the parseState + object. + + + + + + + + + + + An pseudo-abstraction over binary and textual output channels. + OCaml-compatible channels conflate binary and text IO, and for this reasons their + use from F# is somewhat deprecated The direct use of System.IO StreamWriter, TextWriter and + BinaryWriter objects is preferred, e.g. see System.IO.File.CreateText). Well-written OCaml code + that simply opens either a channel in text or binary mode and then does text + or binary I/O using the OCaml functions will work, though care must + be taken with regard to end-of-line characters (see output_char below). + + This library pretends that an out_channel is just a System.IO.TextWriter. Channels + created using open_out_bin maintain a private System.IO.BinaryWriter, which will be used whenever + do I/O using this channel. + + + + + A pseudo-abstraction over binary and textual input channels. + OCaml-compatible channels conflate binary and text IO, and for this reasons their + use from F# is somewhat deprecated (direct use of System.IO StreamReader, TextReader and + BinaryReader objects is preferred, e.g. see System.IO.File.OpenText). + Well-written OCaml-compatible code that simply opens either a channel in text or binary + mode and then does text or binary I/O using the OCaml-compatible functions below + will work, though care must be taken with regard to end-of-line characters (see + input_char below). + + This library pretends that an in_channel is just a System.IO.TextReader. Channel values + created using open_in_bin maintain a private System.IO.BinaryReader, which will be used whenever + you do I/O using this channel. + + InChannel.of_BinaryReader and InChannel.of_StreamReader allow you to build input + channels out of the corresponding .NET abstractions. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + This type is present primarily for compatibility with other versions of ML. When + not cross-compiling we recommend using the .NET I/O libraries + + + + + + + + + + + + + + + + + + + + Throw an <c>KeyNotFoundException</c> exception + + + + + Throw an ArgumentException + + + + +Read a line from the console, without the end-of-line character. + + + + +Read an integer from the console. + + + + +Read a floating point number from the console. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Print a character to the stderr stream + + + + + Flush all pending output on the channel to the physical + output device. + + + + + Set the binary mode. If the binary mode is changed from "true" to + "false" then a StreamWriter is created to write the binary stream. The StreamWriter uses + the default text encoding System.Text.Encoding.Default. + + + + + Set the current position in the output channel, measured from the + start of the channel. + + + + + Return the current position in the output channel, measured from the + start of the channel. Not valid on all channels. + + + + + Serialize the given value to the output channel. + + + + + Write the given Unicode string to the output channel. See output_char for the treatment of + '\n' characters within the string. + + + + + Write the given Unicode character to the output channel. + + If the output channel is a binary stream and the UTF-16 value of the Unicode character is greater + than 255 then ArgumentException is thrown. + + No CRLF translation is done on output. That is, if the output character is + '\n' (LF) characters they will not be written as '\r\n' (CRLF) characters, regardless + of whether the underlying operating system or output stream uses CRLF as the default + line-feed character. + + + + + Write the given byte to the output channel. No CRLF translation is + performed. + + + + + Write the given integer to the output channel in binary format. + Only valid on binary channels. + + + + + Write the given range of bytes to the output channel. + + + + + Return the length of the output channel. + Raise an exception if not an app + + + + + Close the given output channel + + + + + Open the given file to write in the mode according to the specified flags + + + + + Open the given file to write in binary-mode + + + + + Open the given file to write in text-mode using the + System.Text.Encoding.Default encoding + + See output_char for a description of CR-LF translation + done on output. + + + + + + + + Set the binary mode to true or false. If the binary mode is changed from "true" to + "false" then a StreamReader is created to read the binary stream. The StreamReader uses + the default text encoding System.Text.Encoding.Default + + + + + Reads bytes from the channel. Blocks if the bytes are not available. + For text channels this only accepts UTF-16 bytes with an encoding less than 256. + Raise End_of_file (= System.IO.EndOfStreamException) if end of file reached. + + + + + Reads bytes from the channel. Blocks if the bytes are not available. + See 'input' for treatment of text channels. + Raise End_of_file (= System.IO.EndOfStreamException) if end of file reached. + + + + + Report the current position in the input channel + + + + + Input a single serialized value from a binary stream. Raise End_of_file (= System.IO.EndOfStreamException) if end of file reached. + + + + + Input a single line. Raise End_of_file (= System.IO.EndOfStreamException) if end of file reached. + + + + + Input a single character. Raise End_of_file (= System.IO.EndOfStreamException) if end of file reached. + + + + + Input a single byte. + For text channels this only accepts characters with a UTF16 encoding that fits in a byte, e.g. ASCII. + Raise End_of_file (= System.IO.EndOfStreamException) if end of file reached. + + + + + Input a binary integer from a binary channel. Compatible with output_binary_int. + + + + + Attempt to input characters from a channel. Does not block if inpout is not available. + Raise End_of_file (= System.IO.EndOfStreamException) if end of file reached. + + No CRLF translation is done on input, even in text mode. That is, if an input file + has '\r\n' (CRLF) line terminators both characters will be seen in the input. + + + + + Attempt to input the given number of bytes from the channel, writing them into the + buffer at the given start position. Does not block if the bytes are not available. + + The use of this function with a channel performing byte-to-character translation (e.g. one + created with open_in, open_in_utf8 or open_in_encoded, or one + or built from a StreamReader or TextReader) is not recommended. + Instead, open the channel using open_in_bin or InChannel.of_BinaryReader. + + If used with a StreamReader channel, i.e. one created using + open_in, open_in_utf8 or open_in_encoded, or one + or built from a StreamReader, this function reads bytes directly from the underlying + BaseStream. This may not be appropriate if any other input techniques are being + used on the channel. + + If used with a TextReader channel (e.g. stdin), this function reads characters from the + stream and then fills some of the byte array with the decoding of these into + bytes, where the decoding is performed using the System.Text.Encoding.Default encoding + + Raise End_of_file (= System.IO.EndOfStreamException) if end of file reached. + + + + + Return the length of the input channel + + + + + Close the channel + + + + + Open the given file in the mode specified by the given flags + + + + + Open the given file to read in binary-mode + + + + + Open the given file to read. + +In the absence of an explicit encoding (e.g. using Open_encoding) open_in +uses the default text encoding (System.Text.Encoding.Default). If you want to read a file +regardless of encoding then you should use binary modes. Note that .NET's +"new StreamReader" function defaults to use a utf8 encoding, and also attempts +to determine an automatic encoding by looking for "byteorder-marks" at the head +of a text file. This function does not do this. + + No CR-LF translation is done on input. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + This value is present primarily for compatibility with other versions of ML + + + + + This value is present primarily for compatibility with other versions of ML + + + + + This value is present primarily for compatibility with other versions of ML + + + + + This value is present primarily for compatibility with other versions of ML + The smallest value that when added to 1.0 gives a different value to 1.0 + + + + + This value is present primarily for compatibility with other versions of ML + The lowest non-denormalized positive IEEE64 float + + + + + This value is present primarily for compatibility with other versions of ML + The highest representable positive value in the 'float' type + + + + + + + + This value is present primarily for compatibility with other versions of ML. In F# + the overloaded operators may be used. + + + + + This value is present primarily for compatibility with other versions of ML. In F# + the overloaded operators may be used. + + + + + This value is present primarily for compatibility with other versions of ML. In F# + the overloaded operators may be used. + + + + + This value is present primarily for compatibility with other versions of ML. In F# + the overloaded operators may be used. + + + + + This value is present primarily for compatibility with other versions of ML. In F# + the overloaded operators may be used. + + + + + This value is present primarily for compatibility with other versions of ML + + + + + + + + The exception thrown by <c>invalid_arg</c> and misues of F# library functions + + + + + + + + + + + Negation on integers of the 'int' type + + + + + The highest representable value in the 'int' type + + + + + The lowest representable value in the 'int' type + + + + + n+1 (no overflow checking) + + + + + n-1 (no overflow checking) + + + + + 1D Array element set-accessor ('setter') + + + + + 1D Array element get-accessor ('getter') + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Negation of the '==' operator, see also Obj.eq + + + + +Reference/physical equality. +True if boxed versions of the inputs are reference-equal, OR if +both are value types and the implementation of Object.Equals for the type +of the first argument returns true on the boxed versions of the inputs. + +In normal use on reference types or non-mutable value types this function +has the following properties: + - returns 'true' for two F# values where mutation of data + in mutable fields of one affects mutation of data in the other + - will return 'true' if (=) returns true + - hashq will return equal hashes if (==) returns 'true' + +The use on mutable value types is not recommended. + + + + + + + + + + + + + + The exception thrown by 'assert' failures. + A future release of F# may map this exception to a corresponding .NET exception. + + + + + + + + Non-exhaustive match failures will raise Match failures + A future release of F# may map this exception to a corresponding .NET exception. + + + + + + + + + + + + + + + + + + + + + + +The type of simple immutable lists + + + + +The type of None/Some options + + + + +The type of pointers to mutable reference cells + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Concatenate two lists. + + + + + Concatenate two strings. The overlaoded operator '+' may also be used. + + + + +Exit the current hardware isolated process, if security settings permit, +otherwise raise an exception. Calls System.Environment.Exit. + + + + +Increment a mutable reference cell containing an integer + + + + +Decrement a mutable reference cell containing an integer + + + + + + + + + + + + + + + + + Throw an exception + + + + + Throw a 'Failure' exception + + + + +Create a mutable reference cell + + + + +Assign to a mutable reference cell + + + + +Dereference a mutable reference cell + + + + +Absolute value of the given integer + + + + + + + + + + + + + + + + +The "hash" function is a structural hash function. It is +designed to return equal hash values for items that are +equal according to the polymorphic equality +function Pervasives.(=) (i.e. the standard "=" operator). + + + + +Minimum based on structural comparison + + + + +Maximum based on structural comparison + + + + +Structural comparison + + + + +Structural greater-than-or-equal + + + + +Structural greater-than + + + + +Structural equality + + + + +Structural inequality + + + + +Structural less-than-or-equal comparison + + + + +Structural less-than comparison + + + + + + + +Pervasives: Additional OCaml-compatible bindings + + + + + + + + + + + Compatibility module to display data about exceptions. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Simple operations on signed bytes + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +A collection of operations for creating and using sets based on a particular comparison function. +The 'Tag' type parameter is used to track information about the comparison function. + + + + +A functor to build a collection of operations for creating and using + sets based on the given comparison function. This returns a record that + contains the functions you use to create and manipulate maps of + this kind. The returned value is much like an ML module. + + To use this function you need to define a new named class that implements IComparer and + pass an instance of that class as the first argument. For example: + type MyComparer() = + interface IComparer<string> with + member self.Compare(x,y) = ... + + let MyStringSetProvider = Set.MakeTagged(new MyComparer()) + + + + + Build a collection of operations for creating and using + maps based on a single consistent comparison function. This returns a record + that contains the functions you use to create and manipulate maps all of which + use this comparison function. The returned value is much like an ML module. + + Use MakeTagged if you want additional type safety that guarantees that two sets + based on different comparison functions can never be combined in inconsistent ways. + + + + + + + + + + + + + + Immutable sets implemented via binary trees + + + + + Return a string with all characters converted to uppercase. + + + + + Return the index of the first occurrence of the given character + starting from the given index proceeding backwards. + + + + + Return the index of the first occurrence of the given character + from the end of the string proceeding backwards + + + + + Return true if the string contains the given character prior to the given index + + + + + Return the first index of the given character in the + range from the given start position to the end of the string. + Raise <c>KeyNotFoundException</c> if + the string does not contain the given character. + + + + + Return the first index of the given character in the + string. Raise <c>KeyNotFoundException</c> if + the string does not contain the given character. + + + + + Return true is the given string contains the given character in the + range from the given start index to the end of the string. + + + + + Return true is the given string contains the given character in the + range specified by the given start index and the given length + + + + + Return true is the given string contains the given character + + + + + Return s string of length 1 containing the given character + + + + + Return a string of the given length containing repetitions of the given character + + + + + Return a new string with all characters converted to lowercase + + + + + Return a substring of length 'length' starting index 'start'. + + + + + Returns the character at the specified position in the string + + + + + Compare the given strings using ordinal comparison + + + + + Removes all occurrences of a set of characters specified in a + list from the beginning and end of this instance. + + + + + Split the string using the given list of separator characters. + Trimming is also performed at both ends of the string and any empty + strings that result from the split are discarded. + + + + + Return a string with the first character converted to lowercase. + + + + + Return a string with the first character converted to uppercase. + + + + + Compatibility module for string processing. Richer string operations + are available via the member functions on strings and other functionality in + the <c>System.String</c> type + and the <c>System.Text.RegularExpressions</c> namespace. + + + + + Time consumed by the main thread. (for approximate timings). + Generally returns only the processor time used by the main + thread of the application. + + + + + The number of bits in the "int" type. + + + + + Path of the current executable, using + <c>System.IO.Path.Combine(System.AppDomain.CurrentDomain.BaseDirectory,System.AppDomain.CurrentDomain.FriendlyName)</c> + + + + + Run the command and return it's exit code. + + Warning: 'command' currently attempts to execute the string using + the 'cmd.exe' shell processor. If it is not present on the system + then the operation will fail. Use System.Diagnostics.Process + directly to run commands in a portable way, which involves specifying + the program to run and the arguments independently. + + + + + Returns the current working directory for the process using <c>System.IO.Directory.GetCurrentDirectory</c> + + + + + Sets the current working directory for the process using <c>System.IO.Directory.SetCurrentDirectory</c> + + + + + Rename a file on disk using System.IO.File.Move + + + + + Deletes a file using <c>System.IO.File.Delete</c>. + + + + + Call System.Environment.GetEnvironmentVariable. Raise <c>KeyNotFoundException</c> if the variable is not defined. + + + + + Returns true if a file currently exists, using System.IO.File.Exists(s). + + + + + The array of command line options. Gives the command line arguments + as returned by <c>System.Environment.GetCommandLineArgs</c>. + + + + + Sys: Basic system operations (for ML compatibility) + + This module is only included to make it possible to cross-compile + code with other ML compilers. It may be deprecated and/or removed in + a future release. You may wish to use .NET functions directly instead. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + UInt32: ML-like operations on 32-bit System.UInt32 numbers. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + UInt64: basic operations on 64-bit System.UInt64 numbers. + + + + diff --git a/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.PowerPack.Linq.dll b/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.PowerPack.Linq.dll new file mode 100644 index 0000000000000000000000000000000000000000..b6081b4b1f45022e46adabad1d55ebebf178449e Binary files /dev/null and b/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.PowerPack.Linq.dll differ diff --git a/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.PowerPack.Linq.xml b/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.PowerPack.Linq.xml new file mode 100644 index 0000000000000000000000000000000000000000..594ab5a3cb15157e8be384371287c079b1c7fba7 --- /dev/null +++ b/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.PowerPack.Linq.xml @@ -0,0 +1,367 @@ + + +FSharp.PowerPack.Linq + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Convert the quotation expression to LINQ expression trees + + This operation will only succeed for a subset of quotation expressions. + + Exceptions: InvalidArgumentException will be raised if the input expression is + not in the subset that can be converted to a LINQ expression tree + + + + + + + + Compile the quotation expression by first converting to LINQ expression trees + + Exceptions: InvalidArgumentException will be raised if the input expression is + not in the subset that can be converted to a LINQ expression tree + + + + + Evaluate the quotation expression by first converting to LINQ expression trees + + Exceptions: InvalidArgumentException will be raised if the input expression is + not in the subset that can be converted to a LINQ expression tree + + + + + Compile the quotation expression by first converting to LINQ expression trees + + Exceptions: InvalidArgumentException will be raised if the input expression is + not in the subset that can be converted to a LINQ expression tree + + + + + Compile the quotation expression by first converting to LINQ expression trees + + Exceptions: InvalidArgumentException will be raised if the input expression is + not in the subset that can be converted to a LINQ expression tree + + + + + + + + An intrinsic for compiling <c>&lt;@ x <> y @&gt;</c> to expression trees + + + + + + + + This join operator implements the LINQ GroupJoin operator and the <c>query</c> convertor recognises it as such + + + + + This join operator corresponds to the LINQ Join operator and the <c>query</c> convertor recognises it as such + + + + + When used in queries, this operator corresponds to the LINQ Join operator and the <c>query</c> convertor recognises it as such + + + + + When used in queries, this operator corresponds to the LINQ Max operator and the <c>query</c> convertor recognises it as such + It differs in return type from <c>Seq.maxBy</c> + + + + + When used in queries, this operator corresponds to the LINQ Min operator and the <c>query</c> convertor recognises it as such + It differs in return type from <c>Seq.minBy</c> + + + + + When used in queries, this operator corresponds to the LINQ Contains operator and the <c>query</c> convertor recognises it as such + + + + + Evaluate the quotation expression by first converting to a LINQ expression tree + making use of IQueryable operators and then executing expression tree + + Exceptions: <c>InvalidArgumentException</c> will be raised if the input expression is + not in the subset that can be converted to a LINQ expression tree + + + + + + + + This function should not be called directly. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + A set of types used for implementing quotation conversions. + These are public only because targets of Linq Lambda expressions require them to be so + + + + + This module provides Compile and Eval extension members + for F# quotation values, implemented by translating to LINQ + expression trees and using the LINQ dynamic compiler. + + + + diff --git a/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.PowerPack.Metadata.dll b/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.PowerPack.Metadata.dll new file mode 100644 index 0000000000000000000000000000000000000000..e4ff28c4c8b74896c1fa55638b9fc25a4b0431c5 Binary files /dev/null and b/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.PowerPack.Metadata.dll differ diff --git a/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.PowerPack.Metadata.xml b/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.PowerPack.Metadata.xml new file mode 100644 index 0000000000000000000000000000000000000000..dae6b1cea242ad18183763349a7fdc9d5c2a427e --- /dev/null +++ b/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.PowerPack.Metadata.xml @@ -0,0 +1,15761 @@ + + +FSharp.PowerPack.Metadata + + + + + + + + + + + + + + + + The value '%s' is not accessible from this code location + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:970) + + + + + The union cases or fields of the type '%s' are not accessible from this code location + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:969) + + + + + The union case '%s' is not accessible from this code location + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:971) + + + + + The value or constructor '%s' is not defined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:6) + + + + + The value, namespace, type or module '%s' is not defined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:7) + + + + + The value, constructor, namespace or type '%s' is not defined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:5) + + + + + The type parameter '%s' is not defined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:12) + + + + + The type '%s' is not defined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:9) + + + + + The record label or namespace '%s' is not defined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:10) + + + + + The record label '%s' is not defined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:11) + + + + + The pattern discriminator '%s' is not defined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:13) + + + + + The namespace or module '%s' is not defined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:3) + + + + + The namespace '%s' is not defined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:2) + + + + + The field, constructor or member '%s' is not defined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:4) + + + + + The constructor, module or namespace '%s' is not defined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:8) + + + + + The type '%s' implements 'System.IComparable'. Consider also adding an explicit override for 'Object.Equals' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:179) + + + + + The type '%s' implements 'System.IComparable' explicitly but provides no corresponding override for 'Object.Equals'. An implementation of 'Object.Equals' has been automatically provided, implemented via 'System.IComparable'. Consider implementing the override 'Object.Equals' explicitly + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:180) + + + + + The signature and implementation are not compatible because the respective type parameter counts differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:175) + + + + + The signature and implementation are not compatible because the type parameter '%s' has a constraint of the form %s but the implementation does not. Either remove this constraint from the signature or add it to the implementation. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:178) + + + + + The signature and implementation are not compatible because the declaration of the type parameter '%s' requires a constraint of the form %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:177) + + + + + The signature and implementation are not compatible because the type parameter in the class/signature has a different compile-time requirement to the one in the member/implementation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:176) + + + + + The override for '%s' was ambiguous + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:195) + + + + + The override '%s' implements more than one abstract slot, e.g. '%s' and '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:198) + + + + + No implementations of '%s' had the correct number of arguments and type parameters. The required signature is '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:194) + + + + + No implementation was given for '%s'. Note that all interface members must be implemented and listed under an appropriate 'interface' declaration, e.g. 'interface ... with member ...'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:203) + + + + + No implementation was given for '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:202) + + + + + The interface '%s' is included in multiple explicitly implemented interface types. Add an explicit implementation of this interface. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:200) + + + + + A named argument has been assigned more than one value + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:201) + + + + + More than one override implements '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:196) + + + + + The namespace or module attributes differ between signature and implementation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:192) + + + + + The method '%s' is sealed and cannot be overridden + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:197) + + + + + This method is over-constrained in its type parameters + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:193) + + + + + The member '%s' does not have the correct number of method type parameters. The required signature is '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:205) + + + + + The member '%s' does not have the correct number of arguments. The required signature is '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:204) + + + + + The member '%s' does not have the correct kinds of generic parameters. The required signature is '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:206) + + + + + The member '%s' cannot be used to implement '%s'. The required signature is '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:207) + + + + + Invalid value + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:174) + + + + + The struct, record or union type '%s' has an explicit implementation of 'Object.GetHashCode' or 'Object.Equals'. You must apply the 'CustomEquality' attribute to the type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:181) + + + + + The struct, record or union type '%s' has an explicit implementation of 'Object.GetHashCode'. Consider implementing a matching override for 'Object.Equals(obj)' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:182) + + + + + The struct, record or union type '%s' has an explicit implementation of 'Object.Equals'. Consider implementing a matching override for 'Object.GetHashCode()' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:183) + + + + + Duplicate or redundant interface + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:199) + + + + + The implicit instantiation of a generic construct at or near this point could not be resolved because it could resolve to multiple unrelated types, e.g. '%s' and '%s'. Consider using type annotations to resolve the ambiguity + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:169) + + + + + Could not resolve the ambiguity in the use of a generic construct with an 'unmanaged' constraint at or near this position + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1108) + + + + + Could not resolve the ambiguity inherent in the use of a 'printf'-style format string + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:171) + + + + + Could not resolve the ambiguity inherent in the use of the operator '%s' at or near this program point. Consider using type annotations to resolve the ambiguity. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:170) + + + + + Could not resolve the ambiguity in the use of a generic construct with an 'enum' constraint at or near this position + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:172) + + + + + Could not resolve the ambiguity in the use of a generic construct with a 'delegate' constraint at or near this position + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:173) + + + + + The type '%s' is not accessible from this code location + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:968) + + + + + union case + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:945) + + + + + type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:941) + + + + + property + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:950) + + + + + patvar + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:952) + + + + + and %d other overloads + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:944) + + + + + namespace/module + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:955) + + + + + namespace + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:953) + + + + + module + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:954) + + + + + inherits + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:942) + + + + + implements + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:943) + + + + + Full name + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:940) + + + + + also from %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:957) + + + + + from %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:956) + + + + + field + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:948) + + + + + event + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:949) + + + + + argument + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:951) + + + + + active recognizer + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:947) + + + + + active pattern result + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:946) + + + + + Unexpected TExpr_tchoose + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:981) + + + + + Note: Lambda-lifting optimizations have not been applied because of the use of this local constrained generic function as a first class value. Adding type constraints may resolve this condition. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:982) + + + + + The 'VolatileField' attribute may only be used on 'let' bindings in classes + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:689) + + + + + Volatile fields must be marked 'mutable' and cannot be thread-static + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:746) + + + + + A declaration may only be given a value in a signature if the declaration has the [<Literal>] attribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:744) + + + + + In sequence expressions, multiple results are generated using 'yield!' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:663) + + + + + Character range matches have been removed in F#. Consider using a 'when' pattern guard instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:596) + + + + + Use 'typeof<_>' instead + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:610) + + + + + The use of 'let! x = coll' in sequence expressions is no longer permitted. Use 'for x in coll' instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:661) + + + + + This attribute cannot be used in this version of F# + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:716) + + + + + Unrecognized attribute target. Valid attribute targets are 'assembly', 'module', 'type', 'method', 'property', 'return', 'param', 'field', 'event', 'constructor'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:706) + + + + + Unrecognized accessibility specification + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:508) + + + + + The unnamed arguments do not form a prefix of the arguments of the method called + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:683) + + + + + Unknown union case + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:534) + + + + + Unit-of-measure cannot be used in type constructor application + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:572) + + + + + This union case takes one argument + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:590) + + + + + This union case expects %d arguments in tupled form + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:591) + + + + + This union case does not take arguments + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:589) + + + + + Uninitialized 'val' fields in implicit construction types must be mutable and marked with the '[<DefaultValue>]' attribute. Consider using a 'let' binding instead of a 'val' field. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:747) + + + + + Unexpected type arguments + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:581) + + + + + Unexpected type application + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:664) + + + + + Unexpected %s in type expression + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:575) + + + + + Unexpected / in type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:580) + + + + + Unexpected source-level property specification + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:545) + + + + + Unexpected source-level property specification in syntax tree + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:539) + + + + + Unexpected Measure_Anon + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:494) + + + + + Unexpected expression at recursive inference point + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:524) + + + + + Unexpected constraints or parameters on module specification + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:787) + + + + + Unexpected constraint or type definition + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:788) + + + + + Unexpected Const_uint16array + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:499) + + + + + Unexpected Const_bytearray + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:500) + + + + + Unexpected condition in imported assembly: failed to decode AttributeUsage attribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:705) + + + + + Unexpected big rational constant + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:497) + + + + + The field '%s' has been given a value, but is not present in the type '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:629) + + + + + Unable to parse format string '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:606) + + + + + Types cannot inherit from multiple concrete types + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:797) + + + + + Types cannot contain nested type definitions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:776) + + + + + Struct types are always sealed + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:809) + + + + + Record types are always sealed + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:807) + + + + + Enum types are always sealed + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:811) + + + + + Delegate types are always sealed + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:810) + + + + + Discriminated union types are always sealed + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:806) + + + + + Assembly code types are always sealed + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:808) + + + + + The type '%s' is used in an invalid way. A value prior to '%s' has an inferred type involving '%s', which is an invalid forward reference. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:834) + + + + + This type requires a definition + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:794) + + + + + The type parameters inferred for this value are not stable under the erasure of type abbreviations. This is due to the use of type abbreviations which drop or reorder type parameters, e.g. \n\ttype taggedInt<'a> = int or\n\ttype swap<'a,'b> = 'b * 'a.\nConsider declaring the type parameters for this value explicitly, e.g.\n\tlet f<'a,'b> ((x,y) : swap<'b,'a>) : swap<'a,'b> = (y,x). + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:529) + + + + + Type parameter cannot be used as type constructor + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:576) + + + + + This type parameter has been used in a way that constrains it to always be '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:528) + + + + + This value, type or method expects %d type parameter(s) but was given %d + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:551) + + + + + type or module + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:778) + + + + + The type '%s' is not an interface type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:754) + + + + + This type is not an interface type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:771) + + + + + This type is not a record type. Values of class and struct types must be created using calls to object constructors. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:656) + + + + + This type is not a record type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:657) + + + + + This type is not accessible from this code location + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:704) + + + + + This type has no nested types + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:574) + + + + + This type has no accessible object constructors + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:667) + + + + + Fields which are type functions cannot be mutated + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:492) + + + + + type, exception or module + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:777) + + + + + Type definitions using implicit construction may only have one 'inherit' specification and it must be the first declaration + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:827) + + + + + Type definitions using implicit construction must have local let/do-bindings preceding member and interface definitions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:828) + + + + + This type definition involves an immediate cyclic reference through a struct field or inheritance relation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:823) + + + + + This type definition involves an immediate cyclic reference through an abbreviation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:822) + + + + + The type '%s' is not a type whose values can be enumerated with this syntax, i.e. is not compatible with either seq<_>, IEnumerable<_> or IEnumerable and does not have a GetEnumerator method + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:558) + + + + + Type abbreviations cannot have members + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:761) + + + + + Type abbreviations cannot have interface declarations + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:769) + + + + + Type abbreviations cannot have augmentations + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:832) + + + + + This type abbreviation has one or more declared type parameters that do not appear in the type being abbreviated. Type abbreviations must use all declared type parameters in the type being abbreviated. Consider removing one or more type parameters, or use a concrete type definition that wraps an underlying type, such as 'type C<'a> = C of ...'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:795) + + + + + 'try'/'with' cannot be used within sequence expressions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:662) + + + + + Thread-static and context-static variables must be static and given the [<DefaultValue>] attribute to indicate that the value is initialized to the default value on each new thread + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:745) + + + + + The syntax 'expr.id' may only be used with record labels, properties and fields + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:678) + + + + + Syntax error - unexpected '?' symbol + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:598) + + + + + '%s' may only be used to construct object types + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:627) + + + + + The struct, record or union type '%s' has the 'StructuralEquality' attribute but the component type '%s' does not satisfy the 'equality' constraint + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1085) + + + + + The struct, record or union type '%s' has the 'StructuralEquality' attribute but the type parameter '%s' does not satisfy the 'equality' constraint. Consider adding the 'equality' constraint to the type parameter + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1084) + + + + + The struct, record or union type '%s' has the 'StructuralComparison' attribute but the component type '%s' does not satisfy the 'comparison' constraint + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1079) + + + + + The struct, record or union type '%s' has the 'StructuralComparison' attribute but the type parameter '%s' does not satisfy the 'comparison' constraint. Consider adding the 'comparison' constraint to the type parameter + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1078) + + + + + Each argument of the primary constructor for a struct must be given a type, for example 'type S(x1:int, x2: int) = ...'. These arguments determine the fields of the struct. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1086) + + + + + Structs cannot contain 'let' bindings because the default constructor for structs will not execute these bindings. Consider adding additional arguments to the primary constructor for the type. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:765) + + + + + Structs cannot contain 'do' bindings because the default constructor for structs would not execute these bindings + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:764) + + + + + Structs, interfaces, enums and delegates cannot inherit from other types + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:796) + + + + + Structs cannot have an object constructor with no arguments. This is a restriction imposed on all CLI languages as structs automatically support a default constructor. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:737) + + + + + Structs may only bind a 'this' parameter at member declarations + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:523) + + + + + Struct types cannot contain abstract members + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:816) + + + + + Static 'val' fields in types must be mutable, private and marked with the '[<DefaultValue>]' attribute. They are initialized to the 'null' or 'zero' value for their type. Consider also using a 'static let mutable' binding in a class type. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:748) + + + + + Static optimization conditionals are only for use within the F# library + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:684) + + + + + This static member should not have a 'this' parameter. Consider using the notation 'member Member(args) = ...'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:542) + + + + + Static 'let' bindings may only be defined in class types with implicit constructors + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:766) + + + + + Interfaces cannot contain definitions of static initializers + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:732) + + + + + A static initializer requires an argument + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:540) + + + + + A static field was used where an instance field is expected + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:490) + + + + + A simple method name is required here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:636) + + + + + In sequence expressions, results are generated using 'yield' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:496) + + + + + Return values cannot have names + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:502) + + + + + Return types of union cases must be identical to the type being defined, up to abbreviations + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:752) + + + + + The syntax 'type X with ...' is reserved for augmentations. Types whose representations are hidden but which have members are now declared in signatures using 'type X = ...'. You may also need to add the '[<Sealed>] attribute to the type declaration in the signature + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:824) + + + + + This is not a variable, constant, active recognizer or literal + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:594) + + + + + This control construct may only be used if the computation expression builder defines a '%s' method + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:573) + + + + + Only active patterns returning exactly one result may accept arguments + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:586) + + + + + The representation of this type is hidden by the signature. It must be given an attribute such as [<Sealed>], [<Class>] or [<Interface>] to indicate the characteristics of the type. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:802) + + + + + Recursive bindings that include member specifications can only occur as a direct augmentation of a type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:739) + + + + + Records, union, abbreviations and struct types cannot have the 'AllowNullLiteral' attribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:798) + + + + + This record contains fields from inconsistent types + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:521) + + + + + A property cannot have explicit type parameters. Consider using a method instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:536) + + + + + This property or field was not found on this custom attribute type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:711) + + + + + Property '%s' is static + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:675) + + + + + Property '%s' is not static + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:672) + + + + + Property '%s' is not readable + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:673) + + + + + The property implemented by this default is ambiguous + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:729) + + + + + Property '%s' cannot be set + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:676) + + + + + This property cannot be set + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:710) + + + + + This property already has a default implementation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:728) + + + + + The types System.ValueType, System.Enum, System.Delegate, System.MulticastDelegate and System.Array cannot be used as super types in an object expression or class + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:637) + + + + + A parameter with attributes must also be given a name, e.g. '[<Attribute>] paramName : paramType' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:501) + + + + + The parameter '%s' was inferred to have byref type. Parameters of byref type must be given an explicit type annotation, e.g. 'x1: byref<int>'. When used, a byref parameter is implicitly dereferenced. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1103) + + + + + You must explicitly declare either all or no type parameters when overriding a generic abstract method + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:531) + + + + + Accessibility modifiers are not permitted on overrides or interface implementations + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:805) + + + + + This override takes a different number of arguments to the corresponding abstract member + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:722) + + + + + One or more of the overloads of this method has curried arguments. Consider redesigning these members to take arguments in tupled form. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:682) + + + + + Optional arguments cannot be used in custom attributes + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:709) + + + + + Optional arguments are only permitted on type members + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:582) + + + + + Optional arguments must come at the end of the argument list, after any non-optional arguments + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1122) + + + + + This declaration opens the namespace or module '%s' through a partially qualified path. Adjust this code to use the full path of the namespace. This change will make your code more robust as new constructs are added to the F# and CLI libraries. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:759) + + + + + Only types representing units-of-measure may be given the 'Measure' attribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:804) + + + + + Only structs and classes without implicit constructors may be given the 'StructLayout' attribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:801) + + + + + Only simple variable patterns can be bound in 'let rec' constructs + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:740) + + + + + Only simple bindings of the form 'id = expr' can be used in construction expressions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:643) + + + + + Only record fields and simple 'let' bindings may be marked mutable + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:741) + + + + + Only functions may be marked 'inline' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:698) + + + + + Only classes may be given the 'AbstractClass' attribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:803) + + + + + Objects must be initialized by an object construction expression that calls an inherited object constructor and assigns a value to each field + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:644) + + + + + The operator 'expr.[idx]' has been used an object of indeterminate type based on information prior to this program point. Consider adding further type constraints + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:618) + + + + + Only overrides of abstract and virtual members may be specified in object expressions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:632) + + + + + This form of object expression is not used in F#. Use 'member this.MemberName ... = ...' to define member implementations in object expressions. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:546) + + + + + Calls to object constructors on type parameters cannot be given arguments + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:620) + + + + + Interfaces cannot contain definitions of object constructors + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:733) + + + + + An object constructor requires an argument + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:541) + + + + + Object construction expressions (i.e. record expressions with inheritance specifications) may only be used to implement constructors in object model types. Use 'new ObjectType(args)' to construct instances of object model types outside of constructors + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:654) + + + + + Object construction expressions may only be used to implement constructors in class types + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:642) + + + + + This numeric literal requires that a module '%s' defining functions FromZero, FromOne, FromInt32, FromInt64 and FromString be in scope + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:650) + + + + + This is not a valid name for an enumeration case + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:611) + + + + + This code is not sufficiently generic. The type variable %s could not be generalized because it would escape its scope. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:535) + + + + + Not an exception + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:786) + + + + + Non-zero constants cannot have generic units. For generic zero, write 0.0<_>. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:495) + + + + + The generic member '%s' has been used at a non-uniform instantiation prior to this program point. Consider reordering the members so this member occurs first. Alternatively, specify the full type of the member explicitly, including argument types, return type and any additional generic parameters and constraints. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1104) + + + + + This value is not a literal and cannot be used in a pattern + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:554) + + + + + No abstract property was found that corresponds to this override + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:725) + + + + + No abstract or interface member was found that corresponds to this override + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:721) + + + + + Interface implementations cannot be given on construction expressions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:641) + + + + + The struct, record or union type '%s' does not support structural equality because the type '%s' does not satisfy the 'equality' constraint. Consider adding the 'NoEquality' attribute to the type '%s' to clarify that the type does not support structural equality + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1083) + + + + + The struct, record or union type '%s' does not support structural equality because the type parameter %s does not satisfy the 'equality' constraint. Consider adding the 'NoEquality' attribute to the type '%s' to clarify that the type does not support structural equality + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1082) + + + + + The struct, record or union type '%s' is not structurally comparable because the type '%s' does not satisfy the 'comparison' constraint. Consider adding the 'NoComparison' attribute to the type '%s' to clarify that the type is not comparable + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1081) + + + + + The struct, record or union type '%s' is not structurally comparable because the type parameter %s does not satisfy the 'comparison' constraint. Consider adding the 'NoComparison' attribute to the type '%s' to clarify that the type is not comparable + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1080) + + + + + No arguments may be given when constructing a record value + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:640) + + + + + The member '%s' does not correspond to any abstract or virtual method available to override or implement + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:633) + + + + + 'new' may only be used with object constructors + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:648) + + + + + 'new' must be used with a named type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:638) + + + + + This new member hides the abstract member '%s' once tuples, functions and/or units of measure are erased. Rename the member or use 'override' instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:731) + + + + + This new member hides the abstract member '%s'. Rename the member or use 'override' instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:730) + + + + + 'new' cannot be used on interface types. Consider using an object expression '{ new ... with ... }' instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:624) + + + + + Namespaces cannot contain values. Consider using a module to hold your value declarations. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:504) + + + + + Namespaces cannot contain extension members except in the same file and namespace where the type is defined. Consider using a module to hold declarations of extension members. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:505) + + + + + '%s' may only be used with named types + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:622) + + + + + The use of named arguments in union case expressions is reserved for future use. Arguments of the form 'a=b' should be parenthesized. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1105) + + + + + Named arguments cannot be given to member trait calls + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:609) + + + + + The named argument '%s' did not match any argument or mutable property + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:681) + + + + + Name '%s' not bound in pattern context + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:583) + + + + + Named arguments must appear after all other arguments + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:556) + + + + + Mutable function values should be written 'let mutable f = (fun args -> ...)' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:697) + + + + + Mutable values cannot have generic parameters + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:696) + + + + + Mutable values cannot be marked 'inline' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:695) + + + + + Multiple visibility attributes have been specified for this identifier. 'let' bindings in classes are always private, as are any 'let' bindings inside expressions. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:507) + + + + + Multiple visibility attributes have been specified for this identifier + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:506) + + + + + Modules cannot use named module signature definitions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:837) + + + + + This declaration opens the module '%s', which is marked as 'RequireQualifiedAccess'. Adjust your code to use qualified references to the elements of the module instead, e.g. 'List.map' instead of 'map'. This change will ensure that your code is robust as new constructs are added to libraries. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:758) + + + + + The path '%s' is a namespace. A module abbreviation may not abbreviate a namespace. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:833) + + + + + Method overrides and interface implementations are not permitted here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:720) + + + + + Method '%s' is not accessible from this code location + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:491) + + + + + Members that extend interface, delegate or enum types must be placed in a module separate to the definition of the type. This module must either have the AutoOpen attribute or be opened explicitly by client code to bring the extension members into scope. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:825) + + + + + The member '%s' is used in an invalid way. A use of '%s' has been inferred prior to the definition of '%s', which is an invalid forward reference. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:835) + + + + + Interfaces cannot contain definitions of member overrides + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:734) + + + + + Extension members cannot provide operator overloads. Consider defining the operator as part of the type definition instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1125) + + + + + This member is not permitted in an interface implementation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:774) + + + + + MemberKindPropertyGetSet only expected in parse trees + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:503) + + + + + This member is not sufficiently generic + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:742) + + + + + A member and a local class binding both have the name '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:768) + + + + + Measure definitions cannot have type parameters + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:793) + + + + + Measure declarations may have only static members: constructors are not available + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:767) + + + + + Measure declarations may have only static members + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:763) + + + + + This lookup cannot be used here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:674) + + + + + Local class bindings cannot be marked inline. Consider lifting the definition out of the class or else do not mark it as inline. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:760) + + + + + Literal values cannot have generic parameters + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:702) + + + + + A literal value cannot be marked 'mutable' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:700) + + + + + A literal value cannot be marked 'inline' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:701) + + + + + A declaration may only be the [<Literal>] attribute if a constant value is also given, e.g. 'val x : int = 1' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:743) + + + + + This list expression exceeds the maximum size for list literals. Use an array for larger literals and call Array.ToList. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:607) + + + + + 'let' and 'do' bindings are not permitted in class definitions unless an implicit construction sequence is used. You can use an implicit construction sequence by modifying the type declaration to include arguments, e.g. 'type X(args) = ...'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:831) + + + + + This code is less generic than required by its annotations because the explicit type variable '%s' could not be generalized. It was constrained to be '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:525) + + + + + The kind of the type specified by its attributes does not match the kind implied by its definition + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:792) + + + + + Invalid use of a type name and/or object constructor. If necessary use 'new' and apply the constructor to its arguments, e.g. 'new Type(args)'. Overloads are:\n\t%s. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:669) + + + + + Invalid use of a type name and/or object constructor. If necessary use 'new' and apply the constructor to its arguments, e.g. 'new Type(args)'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:668) + + + + + Invalid use of a type name + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:666) + + + + + Invalid use of an interface type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:670) + + + + + Invalid use of a delegate constructor. Use the syntax 'new Type(args)' or just 'Type(args)'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:671) + + + + + The 'UseNullAsTrueValue' attribute flag may only be used with union types that have one nullary case and at least one non-nullary case + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1102) + + + + + 'use' bindings must be of the form 'use <var> = <expr>' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:718) + + + + + Units-of-measure cannot be used as prefix arguments to a type. Rewrite as postfix arguments in angle brackets. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:571) + + + + + Units-of-measure supported only on float, float32, decimal and signed integer types + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:498) + + + + + Literal enumerations must have type int, uint, int16, uint16, int64, uint64, byte, sbyte or char + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:820) + + + + + Invalid type extension + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:790) + + + + + Type arguments cannot be specified here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:585) + + + + + Invalid signature for set member + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:727) + + + + + Invalid record, sequence or computation expression. Sequence expressions should be of the form 'seq { ... }' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:604) + + + + + Invalid record construction + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:651) + + + + + This property has an invalid type. Properties taking multiple indexer arguments should have types of the form 'ty1 * ty2 -> ty3'. Properties returning functions should have types of the form '(ty1 -> ty2)'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:566) + + + + + This is not a valid pattern + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:595) + + + + + Invalid optional assignment to a property or field + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:686) + + + + + The '%s' operator should not normally be redefined. To define overloaded comparison semantics for a particular type, implement the 'System.IComparable' interface in the definition of that type. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:513) + + + + + The '%s' operator should not normally be redefined. To define equality semantics for a type, override the 'Object.Equals' member in the definition of that type. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:514) + + + + + The '%s' operator should not normally be redefined. Consider using a different operator name + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:515) + + + + + Invalid object, sequence or record expression + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:603) + + + + + Invalid object expression. Objects without overrides or interfaces should use the expression form 'new Type(args)' without braces. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:602) + + + + + This is not a valid object construction expression. Explicit object constructors must either call an alternate constructor or initialize all fields of the object and specify a call to a super class constructor. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:561) + + + + + Non-primitive numeric literal constants cannot be used in pattern matches because they can be mapped to multiple different types through the use of a NumericLiteral module. Consider using replacing with a variable, and use 'when <variable> = <constant>' at the end of the match clause. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:584) + + + + + 'new' constraints must take one argument of type 'unit' and return the constructed type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:565) + + + + + Invalid namespace, module, type or union case name + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:750) + + + + + Invalid module name + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:789) + + + + + This recursive binding uses an invalid mixture of recursive forms + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:560) + + + + + The name '(%s)' should not be used as a member name. To define comparison semantics for a type, implement the 'System.IComparable' interface. If defining a static member for use from other CLI languages then use the name '%s' instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:509) + + + + + The name '(%s)' should not be used as a member name. To define equality semantics for a type, override the 'Object.Equals' member. If defining a static member for use from other CLI languages then use the name '%s' instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:510) + + + + + The name '(%s)' should not be used as a member name because it is given a standard definition in the F# library over fixed types + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:512) + + + + + The name '(%s)' should not be used as a member name. If defining a static member for use from other CLI languages then use the name '%s' instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:511) + + + + + Invalid inline specification + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:717) + + + + + Invalid indexer expression + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:617) + + + + + The '%s' operator cannot be redefined. Consider using a different operator name + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:516) + + + + + Internal error. Invalid index into active pattern array + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:588) + + + + + This is not a valid value for an enumeration literal + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:753) + + + + + An 'enum' constraint must be of the form 'enum<type>' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:564) + + + + + Delegate specifications must be of the form 'typ -> typ' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:818) + + + + + Invalid declaration + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:547) + + + + + Invalid constraint: the type used for the constraint is sealed, which means the constraint could only be satisfied by at most one solution + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:563) + + + + + Invalid constraint + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:562) + + + + + This is not a valid constant expression + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:703) + + + + + Invalid assignment + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:665) + + + + + Invalid argument to parameterized pattern label + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:587) + + + + + This is not a valid name for an active pattern + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:693) + + + + + Interfaces inherited by other interfaces should be declared using 'inherit ...' instead of 'interface ...' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1114) + + + + + Interface types cannot be sealed + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:817) + + + + + Interface types and delegate types cannot contain fields + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:812) + + + + + This instance member needs a parameter to represent the object being invoked. Make the member static or use the notation 'member x.Member(args) = ...'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:538) + + + + + The inherited type is not an object model type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:653) + + + + + A inheritance declaration is not permitted here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:757) + + + + + This 'inherit' declaration specifies the inherited type but no arguments. Consider supplying arguments, e.g. 'inherit BaseType(args)'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:829) + + + + + This 'inherit' construction call is not part of an implicit construction sequence. Only the inherited type should be specified at this point. Calls to the inherited constructor should be placed inside the object initialization expression of your object constructor. Alternatively use an implicit construction sequence by modifying the type declaration to include arguments, e.g. 'type X(args) = ...'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:830) + + + + + 'inherit' cannot be used on interface types. Consider implementing the interface by using 'interface ... with ... end' instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:623) + + + + + Implicit product of measures following / + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:493) + + + + + The struct, record or union type '%s' implements the interface 'System.IStructuralEquatable' explicitly. Apply the 'CustomEquality' attribute to the type. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:779) + + + + + The struct, record or union type '%s' implements the interface 'System.IStructuralComparable' explicitly. Apply the 'CustomComparison' attribute to the type. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:520) + + + + + The struct, record or union type '%s' implements the interface 'System.IEquatable<_>' explicitly. Apply the 'CustomEquality' attribute to the type and provide a consistent implementation of the non-generic override 'System.Object.Equals(obj)'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:780) + + + + + The struct, record or union type '%s' implements the interface 'System.IComparable' explicitly. You must apply the 'CustomComparison' attribute to the type. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:518) + + + + + The struct, record or union type '%s' implements the interface 'System.IComparable<_>' explicitly. You must apply the 'CustomComparison' attribute to the type, and should also provide a consistent implementation of the non-generic interface System.IComparable. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:519) + + + + + Illegal syntax in type expression + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:577) + + + + + Illegal pattern + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:597) + + + + + Explicit type declarations for constructors must be of the form 'ty1 * ... * tyN -> resTy'. Parentheses may be required around 'resTy' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:751) + + + + + A literal value cannot be given the [<ThreadStatic>] or [<ContextStatic>] attributes + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:699) + + + + + It is recommended that objects that support the IDisposable interface are created using 'new Type(args)' rather than 'Type(args)' to indicate that resources may be owned by the generated value + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:626) + + + + + Generic types cannot be given the 'StructLayout' attribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:800) + + + + + A generic type parameter has been used in a way that constrains it to always be '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:527) + + + + + The generic function '%s' must be given explicit type argument(s) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:549) + + + + + This function value is being used to construct a delegate type whose signature includes a byref argument. You must use an explicit lambda expression taking %d arguments. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:557) + + + + + The corresponding formal argument is not optional + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:685) + + + + + The field labels and expected type of this record expression or pattern do not uniquely determine a corresponding record type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:532) + + + + + A field/val declaration is not permitted here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:756) + + + + + This field requires a name + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:749) + + + + + No assignment given for field '%s' of type '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:630) + + + + + This field is not a literal and cannot be used in a pattern + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:593) + + + + + This field is readonly + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:555) + + + + + Field '%s' is not static + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:592) + + + + + This field is not mutable + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:612) + + + + + The field '%s' appears twice in this record expression or pattern + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:533) + + + + + All record, union and struct types in FSharp.Core.dll must be explicitly labelled with 'StructuralComparison' or 'NoComparison' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1077) + + + + + Extraneous fields have been given values + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:631) + + + + + This list or array expression includes an element of the form 'if ... then ... else'. Parenthesize this expression to indicate it is an individual element of the list or array, to disambiguate this from a list generated using a sequence expression + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:605) + + + + + This expression form may only be used in sequence and computation expressions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:601) + + + + + The expression form { expr with ... } may only be used with record types. To build object types use { new Type(...) with ... } + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:652) + + + + + The expression form 'expr then expr' may only be used as part of an explicit object constructor + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:608) + + + + + Expected %d expressions, got %d + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:599) + + + + + TcExprUndelayed: delayed + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:600) + + + + + Explicit type specifications cannot be used for exception constructors + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:781) + + + + + Explicit type parameters may only be used on module or member bindings + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:530) + + + + + An explicit static initializer should use the syntax 'static new(args) = expr' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:543) + + + + + Explicit signatures within implementation files may no longer be used + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:836) + + + + + An explicit object constructor should use the syntax 'new(args) = expr' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:544) + + + + + Expected unit-of-measure, not type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:570) + + + + + Expected unit-of-measure parameter, not type parameter. Explicit unit-of-measure parameters must be marked with the [<Measure>] attribute. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:567) + + + + + Expected type parameter, not unit-of-measure parameter + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:568) + + + + + Expected type, not unit-of-measure + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:569) + + + + + Expected an interface type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:645) + + + + + Expected module or namespace parent %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:517) + + + + + Exception abbreviations should not have argument lists + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:782) + + + + + Exception abbreviations must refer to existing exceptions or F# types deriving from System.Exception + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:784) + + + + + Event '%s' is static + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:679) + + + + + Event '%s' is not static + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:680) + + + + + Enumerations cannot have members + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:762) + + + + + Enumerations cannot have interface declarations + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:770) + + + + + The 'EntryPointAttribute' attribute may only be used on function definitions in modules + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:694) + + + + + '{ }' is not a valid expression. Records must include at least one field. Empty sequences are specified by using Seq.empty or an empty list '[]'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:655) + + + + + Duplicate specification of an interface + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:755) + + + + + The method or function '%s' should not be given explicit type argument(s) because it does not declare its type parameters explicitly + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:550) + + + + + 'do!' cannot be used within sequence expressions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:660) + + + + + DLLImport stubs cannot be inlined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:522) + + + + + Delegate specifications must not be curried types. Use 'typ * ... * typ -> typ' for multi-argument delegates, and 'typ -> (typ -> typ)' for delegates returning function values. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:819) + + + + + A delegate constructor must be passed a single function value + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:687) + + + + + The 'DefaultValue' attribute may only be used on 'val' declarations + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:691) + + + + + The default, zero-initializing constructor of a struct type may only be used if all the fields of the struct type admit default initialization + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:552) + + + + + A default implementation of this interface has already been added because the explicit implementation of the interface was not specified at the definition of the type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:773) + + + + + This method already has a default implementation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:723) + + + + + The method implemented by this default is ambiguous + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:724) + + + + + The declared type parameters for this type extension do not match the declared type parameters on the original type '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:826) + + + + + This declaration element is not permitted in an augmentation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:775) + + + + + A custom attribute must invoke an object constructor + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:714) + + + + + A custom attribute must be a reference type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:712) + + + + + The number of args for a custom attribute does not match the expected number of args for the attribute constructor + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:713) + + + + + Couldn't find Dispose on IDisposable, or it was overloaded + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:553) + + + + + Constructors cannot be defined for this type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:738) + + + + + Constructors cannot be specified in exception augmentations + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:736) + + + + + Constructors must be applied to arguments and cannot be used as first-class values. If necessary use an anonymous function '(fun arg1 ... argN -> new Type(arg1,...,argN))'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:677) + + + + + Constructors for the type '%s' must directly or indirectly call its implicit object constructor. Use a call to the implicit object constructor instead of a record expression. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:628) + + + + + This object constructor requires arguments + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:647) + + + + + Constructor expressions for interfaces do not take arguments + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:646) + + + + + A constructor cannot have explicit type parameters. Consider using a static construction method instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:537) + + + + + This construct may only be used within sequence or computation expressions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:615) + + + + + This construct may only be used within list, array and sequence expressions, e.g. expressions of the form 'seq { ... }', '[ ... ]' or '[| ... |]'. These use the syntax 'for ... in ... do ... yield...' to generate elements + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:613) + + + + + This construct may only be used within computation expressions. To return a value from an ordinary function simply write the expression without 'return'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:614) + + + + + This construct may only be used within computation expressions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:616) + + + + + This construct is ambiguous as part of a sequence expression. Nested expressions may be written using 'let _ = (...)' and nested sequences using 'yield! seq {... }'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:659) + + + + + This construct is ambiguous as part of a computation expression. Nested expressions may be written using 'let _ = (...)' and nested computations using 'let! res = builder { ... }'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:658) + + + + + One or more of the explicit class or function type variables for this binding could not be generalized, because they were constrained to other types + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:526) + + + + + Attribute 'System.Diagnostics.ConditionalAttribute' is only valid on methods or attribute classes + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1123) + + + + + The 'ConditionalAttribute' attribute may only be used on members + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:692) + + + + + Interfaces cannot contain definitions of concrete members. You may need to define a constructor on your type, or use implicit class construction, to indicate that the type is a concrete implementation class. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:735) + + + + + The 'CompiledName' attribute cannot be used with this language element + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:621) + + + + + Cannot inherit from a variable type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:619) + + + + + Cannot inherit a sealed type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:814) + + + + + Cannot inherit from interface type. Use interface ... with instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:815) + + + + + Cannot create an extension of a sealed type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:639) + + + + + Cannot call an abstract base member: '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1107) + + + + + A binding cannot be marked both 'use' and 'rec' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:688) + + + + + This expression has a method called GetEnumerator, but its return type is a value type. Methods returning struct enumerators cannot be used in this expression form. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:559) + + + + + The attributes of this type specify multiple kinds for the type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:791) + + + + + Attributes are not allowed within patterns + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:548) + + + + + Attributes are not permitted on 'let' bindings in expressions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:690) + + + + + This attribute is not valid for use on this language element. Assembly attributes should be attached to a 'do ()' declaration, if necessary within an F# module. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:707) + + + + + This attribute is not valid for use on this language element + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:708) + + + + + Attribute expressions must be calls to object constructors + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:715) + + + + + The attribute 'AutoOpen(\"%s\")' in the assembly '%s' did not refer to a valid module or namespace in that assembly and has been ignored + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:838) + + + + + The attribute '%s' appears in both the implementation and the signature, but the attribute arguments differ. Only the attribute from the signature will be included in the compiled code. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1106) + + + + + At least one override did not correctly implement its corresponding abstract member + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:649) + + + + + The member '%s' does not accept the correct number of arguments. One overload accepts %d arguments. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:635) + + + + + The member '%s' does not accept the correct number of arguments, %d arguments are expected + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:634) + + + + + Anonymous unit-of-measure cannot be nested inside another unit-of-measure expression + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:578) + + + + + Anonymous type variables are not permitted in this declaration + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:579) + + + + + Types with the 'AllowNullLiteral' attribute may only inherit from or implement types which also allow the use of the null literal + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:799) + + + + + All implemented interfaces should be declared on the initial declaration of the type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:772) + + + + + Instances of this type cannot be created since it has been marked abstract or not all methods have been given implementations. Consider using an object expression '{ new ... with ... }' instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:625) + + + + + This property overrides or implements an abstract property but the abstract property doesn't have a corresponding %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:726) + + + + + Abstract members are not permitted in an augmentation - they must be defined as part of the type itself + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:719) + + + + + Abbreviations for Common IL exception types must have a matching object constructor + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:785) + + + + + Abbreviations for Common IL exceptions cannot take arguments + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:783) + + + + + Abbreviated types cannot be given the 'Sealed' attribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:813) + + + + + A value must be mutable in order to mutate the contents or take the address of a value type, e.g. 'let mutable x = ...' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:88) + + + + + The value has been copied to ensure the original is not mutated by this operation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:90) + + + + + This value does not have a valid property setter type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:84) + + + + + Unexpected decode of InternalsVisibleToAttribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:95) + + + + + Unexpected decode of InterfaceDataVersionAttribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:96) + + + + + Unexpected decode of AutoOpenAttribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:94) + + + + + Unexpected use of a byref-typed variable + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:87) + + + + + The type %s did not contain the union case '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1098) + + + + + The type %s did not contain the field '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1097) + + + + + The module/namespace '%s' from compilation unit '%s' did not contain the val '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1100) + + + + + The module/namespace '%s' from compilation unit '%s' did not contain the namespace, module or type '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1101) + + + + + The module/namespace '%s' from compilation unit '%s' did not contain the module/namespace '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1099) + + + + + The type/module '%s' is not a concrete module or type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:74) + + + + + The type '%s' has an inline assembly code representation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:75) + + + + + Two modules named '%s' occur in two parts of this assembly + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:77) + + + + + Recursively defined values cannot appear directly as part of the construction of a tuple value within a recursive binding + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:91) + + + + + Recursive values cannot be directly assigned to the non-mutable field '%s' of the type '%s' within a recursive binding. Consider using a mutable field instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:93) + + + + + Recursive values cannot appear directly as a construction of the type '%s' within a recursive binding. This feature has been removed from the F# language. Consider using a record instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:92) + + + + + This is not a constant expression or valid custom attribute value + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:99) + + + + + A namespace and a module named '%s' both occur in two parts of this assembly + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:76) + + + + + Invalid mutation of a constant expression. Consider copying the expression to a mutable local, e.g. 'let mutable x = ...'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:89) + + + + + Invalid member signature encountered because of an earlier error + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:83) + + + + + Invalid form for a property setter. At least one argument is required. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:86) + + + + + Invalid form for a property getter. At least one '()' argument is required when using the explicit syntax. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:85) + + + + + This operation accesses a mutable top-level value defined in another assembly in an unsupported way. The value cannot be accessed through its address. Consider copying the expression to a mutable local, e.g. 'let mutable x = ...', and if necessary assigning the value back after the completion of the operation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1093) + + + + + Two type definitions named '%s' occur in namespace '%s' in two parts of this assembly + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:78) + + + + + This constant cannot be used as a custom attribute value + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:98) + + + + + A module and a type definition named '%s' occur in namespace '%s' in two parts of this assembly + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:79) + + + + + Active patterns cannot return more than 7 possibilities + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:97) + + + + + The struct or class field '%s' is not accessible from this code location + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:973) + + + + + If set to true, then all error messages will just return the filled 'holes' delimited by ',,,'s - this is for language-neutral testing (e.g. localization-invariant baselines). + + + + + Recursive class hierarchy in type '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:965) + + + + + Error reading/writing metadata for the F# compiled DLL '%s'. Was the DLL compiled with an earlier version of the F# compiler? (error: '%s'). + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:70) + + + + + Partial active patterns may only generate one result + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:992) + + + + + Missing variable '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:991) + + + + + Accessibility modifiers are not permitted on an 'inherits' declaration + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:436) + + + + + Accessibility modifiers should come immediately prior to the identifier naming a construct + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:407) + + + + + 'use' bindings are not permitted in modules and are treated as 'let' bindings + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:400) + + + + + 'use' bindings are not permitted in implicit class constructors + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:399) + + + + + Unmatched 'with' or badly formatted 'with' block + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:423) + + + + + Unmatched '(' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:450) + + + + + No body found for this 'let' or 'do'. The body must be indented to the same column as this line. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:449) + + + + + Unmatched 'if' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:455) + + + + + Unmatched 'class', 'interface' or 'struct' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:421) + + + + + Unmatched '[|' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:469) + + + + + Unmatched '[' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:464) + + + + + Unmatched '{' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:470) + + + + + Unmatched 'begin' or 'struct' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:414) + + + + + Unmatched 'begin' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:426) + + + + + Unmatched '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:468) + + + + + Accessibility modifiers are not permitted on union cases. Use 'type U = internal ...' or 'type U = private ...' to give an accessibility to the whole representation. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:444) + + + + + Accessibility modifiers are not permitted here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:405) + + + + + Syntax error: unexpected type parameter specification + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:481) + + + + + A semicolon is not expected at this point + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:403) + + + + + Unexpected infix operator in unit-of-measure expression. Legal operators are '*', '/' and '^'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:479) + + + + + Unexpected integer literal in unit-of-measure expression + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:480) + + + + + Unexpected integer literal in type expression + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:478) + + + + + Unexpected infix operator in type expression + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:476) + + + + + Unexpected identifier: '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:443) + + + + + Unexpected end of input + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:404) + + + + + Unexpected empty type moduleDefn list + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:416) + + + + + Unclosed 'for', e.g. no 'done' found to match this 'for' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:459) + + + + + Unclosed block + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:413) + + + + + Type annotations on property getters and setters must be given after the 'get()' or 'set(v)', e.g. 'with get() : string = ...' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:429) + + + + + Accessibility modifiers are not permitted in this position for type abbreviations + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:439) + + + + + The syntax 'module ... = struct .. end' is not used in F# code. Consider using 'module ... = begin .. end' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:485) + + + + + The syntax 'module ... : sig .. end' is not used in F# code. Consider using 'module ... = begin .. end' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:486) + + + + + Syntax error in labelled type argument + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:475) + + + + + Syntax error + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:419) + + + + + Successive patterns should be separated by spaces or tupled + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:451) + + + + + Successive arguments should be separated by spaces or tupled, and arguments involving function or method applications should be parenthesized + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:463) + + + + + A setter property may have at most two argument groups + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1090) + + + + + Property setters must be defined using 'set value = ', 'set idx value = ' or 'set (idx1,...,idxN) value = ... ' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:432) + + + + + Accessibility modifiers are not permitted on record fields. Use 'type R = internal ...' or 'type R = private ...' to give an accessibility to the whole representation. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:447) + + + + + In F# code you may use 'expr.[expr]'. A type annotation may be required to indicate the first expression is an array + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:466) + + + + + At most one 'with' augmentation is permitted + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:402) + + + + + Only '#' compiler directives may occur prior to the first 'namespace' declaration + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:406) + + + + + Only class types may take value arguments + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:425) + + + + + The use of the type syntax 'int C' and 'C <int>' is not permitted here. Consider adjusting this type to be written in the form 'C<int>' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1096) + + + + + Type parameters must be placed directly adjacent to the type name, e.g. \"type C<'T>\", not type \"C <'T>\" + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1094) + + + + + Type arguments must be placed directly adjacent to the type name, e.g. \"C<'T>\", not \"C <'T>\" + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1095) + + + + + No matching 'in' found for this 'let' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:452) + + + + + No #endif found for #if or #else + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:397) + + + + + No '=' symbol should follow a 'namespace' declaration + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:484) + + + + + Files should begin with either a namespace or module declaration, e.g. 'namespace SomeNamespace.SubNamespace' or 'module SomeNamespace.SomeModule', but not both. To define a module within a namespace use 'module SomeModule = ...' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:408) + + + + + Multiple accessibilities given for property getter or setter + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:431) + + + + + The syntax '(typ,...,typ) ident' is not used in F# code. Consider using 'ident<typ,...,typ>' instead + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:477) + + + + + A module name must be a simple name, not a path + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:415) + + + + + A module abbreviation must be a simple name, not a path + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:409) + + + + + Missing qualification after '.' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:465) + + + + + Missing function body + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:473) + + + + + Mismatched quotation, beginning with '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:467) + + + + + Mismatched quotation operator name, beginning with '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:482) + + + + + This member is not permitted in an object implementation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:472) + + + + + The declaration form 'let ... and ...' for non-recursive bindings is not used in F# code. Consider using a sequence of 'let' bindings + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:448) + + + + + Invalid property getter or setter + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1091) + + + + + Invalid operator definition. Prefix operator definitions must use a valid prefix operator name. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1116) + + + + + Invalid prefix operator + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1115) + + + + + Invalid declaration syntax + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:427) + + + + + Interfaces always have the same visibility as the enclosing type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:433) + + + + + An integer for loop must use a simple identifier + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:401) + + + + + Accessibility modifiers are not permitted on inline assembly code types + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:442) + + + + + 'inherit' declarations cannot have 'as' bindings. To access members of the base class when overriding a method, the syntax 'base.SomeMember' may be used; 'base' is a keyword. Remove this 'as' binding. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:437) + + + + + An indexer property must be given at least one argument + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1092) + + + + + Ignoring visibility attribute on module abbreviation. Module abbreviations are always private. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:412) + + + + + Ignoring accessibility attribute on module abbreviation. Module abbreviations are always private. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:411) + + + + + Ignoring attributes on module abbreviation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:410) + + + + + Identifier expected + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:460) + + + + + A getter property is expected to be a function, e.g. 'get() = ...' or 'get(index) = ...' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:430) + + + + + A getter property may have at most one argument group + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1089) + + + + + 'get', 'set' or 'get,set' required + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:424) + + + + + 'get' and/or 'set' required + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:428) + + + + + Field bindings must have the form 'id = expr;' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:471) + + + + + Block following this '%s' is unfinished. Expect an expression. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:454) + + + + + Error in the return expression for this 'let'. Possible incorrect indentation. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:453) + + + + + Error in 'function' block + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:474) + + + + + '=' expected + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:461) + + + + + End of file in verbatim string embedded in comment begun at or before here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:394) + + + + + End of file in verbatim string begun at or before here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:391) + + + + + End of file in string embedded in comment begun at or before here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:393) + + + + + End of file in string begun at or before here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:390) + + + + + End of file in IF-OCAML section begun at or before here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:395) + + + + + End of file in #if section begun at or after here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:389) + + + + + End of file in directive begun at or before here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:396) + + + + + End of file in comment begun at or before here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:392) + + + + + Accessibility modifiers are not permitted in this position for enum types + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:440) + + + + + Accessibility modifiers are not permitted on enumeration fields + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:445) + + + + + A type definition requires one or more members or other declarations. If you intend to define an empty class, struct or interface, then use 'type ... = class end', 'interface end' or 'struct end'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:422) + + + + + 'done' expected after this expression + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:457) + + + + + 'do' expected after this expression + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:458) + + + + + Accessibility modifiers are not permitted on 'do' bindings + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:388) + + + + + Consider using a separate record type instead + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:446) + + + + + Augmentations are not permitted on delegate type moduleDefns + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:420) + + + + + Attributes should be placed before 'val' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:417) + + + + + Attributes are not permitted on 'inherit' declarations + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:435) + + + + + Attributes are not allowed here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:438) + + + + + Attributes have been ignored in this construct + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:398) + + + + + Attributes are not permitted on interface implementations + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:418) + + + + + 'assert' may no longer be used as a first class value. Use 'assert <expr>' instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:456) + + + + + The use of '->' in sequence and computation expressions is limited to the form 'for pat in expr -> expr'. Use the syntax 'for ... in ... do ... yield...' to generate elements in more complex sequence expressions. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:462) + + + + + All enum fields must be given values + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:441) + + + + + Active pattern case identifiers must begin with an uppercase letter + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:483) + + + + + Accessibility modifiers are not allowed on this member. Abstract slots always have the same visibility as the enclosing type. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:434) + + + + + Write the xmldoc of the assembly to the given file + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:876) + + + + + Specify a Win32 resource file (.res) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:884) + + + + + Specify a Win32 manifest file + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:885) + + + + + Report all warnings as errors + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:894) + + + + + Report specific warnings as errors + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:895) + + + + + Set a warning level (0-4) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:896) + + + + + Output messages in UTF-8 encoding + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:904) + + + + + Unrecognized target '%s', expected 'exe', 'winexe', 'library' or 'module' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:913) + + + + + Unrecognized debug type '%s', expected 'pdbonly' or 'full' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:914) + + + + + Unrecognized platform '%s', valid values are 'x86', 'x64', 'Itanium', and 'anycpu' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:928) + + + + + Unknown --test argument: '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:927) + + + + + Enable or disable tailcalls + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:892) + + + + + Specify a strong name key file + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:877) + + + + + Specify a strong name key container + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:878) + + + + + Statically link the given assembly and all referenced DLLs that depend on this assembly. Use an assembly name e.g. mylib, not a DLL name. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:910) + + + + + Statically link the F# library and all referenced DLLs that depend on it into the assembly being generated + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:909) + + + + + Resolve assembly references using directory-based mono rules rather than MSBuild resolution (Default=false except when running fsc.exe under mono) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:912) + + + + + Print the inferred interface of the assembly to a file + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:882) + + + + + Short form of '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:916) + + + + + Embed the specified managed resource + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:887) + + + + + Reference an assembly (Short form: -r) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:883) + + + + + Problem with codepage '%d': %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:868) + + + + + Limit which platforms this code can run on: x86, Itanium, x64 or anycpu. The default is anycpu. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:879) + + + + + Name the output debug file + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:911) + + + + + Enable optimizations (Short form: -O) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:891) + + + + + Do not include the default Win32 manifest + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:886) + + + + + Disable specific warning messages + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:897) + + + + + Suppress compiler copyright message + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:901) + + + + + Do not reference the default CLI assemblies by default + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:908) + + + + + Only include optimization information essential for implementing inlined constructs. Inhibits cross-module inlining but improves binary compatibility. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:880) + + + + + Don't add a resource to the generated assembly containing F#-specific metadata + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:881) + + + + + Name of the output file (Short form: -o) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:870) + + + + + Ignore ML compatibility warnings + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:900) + + + + + Link the specified resource to this assembly where the resinfo format is <file>[,<string name>[,public|private]] + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:888) + + + + + Specify a directory for the include path which is used to resolve source files and assemblies (Short form: -I) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:906) + + + + + Invalid warning level '%d' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:915) + + + + + The command-line option '%s' is for internal use only + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:929) + + + + + - RESOURCES - + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:921) + + + + + - OUTPUT FILES - + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:919) + + + + + - MISCELLANEOUS - + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:924) + + + + + - LANGUAGE - + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:925) + + + + + - INPUT FILES - + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:920) + + + + + - ERRORS AND WARNINGS - + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:926) + + + + + - CODE GENERATION - + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:922) + + + + + - ADVANCED - + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:923) + + + + + Display this usage message (Short form: -?) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:902) + + + + + Output messages with fully qualified paths + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:905) + + + + + Delay-sign the assembly using only the public portion of the strong name key + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:875) + + + + + Define conditional compilation symbols (Short form: -d) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:899) + + + + + Emit debug information (Short form: -g) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:889) + + + + + Specify debugging type: full, pdbonly. ('full' is the default and enables attaching a debugger to a running program). + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:890) + + + + + The command-line option '%s' has been deprecated + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:930) + + + + + The command-line option '%s' has been deprecated. HTML document generation is now part of the F# Power Pack, via the tool FsHtmlDoc.exe. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:932) + + + + + The command-line option '%s' has been deprecated. Use '%s' instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:931) + + + + + Enable or disable cross-module optimizations + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:893) + + + + + Copyright (c) Microsoft Corporation. All Rights Reserved. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:869) + + + + + Specify the codepage used to read source files + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:903) + + + + + Use to override where the compiler looks for mscorlib.dll and framework components + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:918) + + + + + The command-line option '--cliroot' has been deprecated. Use an explicit reference to a specific copy of mscorlib.dll instead. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:917) + + + + + Generate overflow checks + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:898) + + + + + Build a Windows executable + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:872) + + + + + Build a module that can be added to another assembly + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:874) + + + + + Build a library (Short form: -a) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:873) + + + + + Build a console executable + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:871) + + + + + Base address for the library to be built + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:907) + + + + + A value marked as 'inline' has an unexpected value + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1007) + + + + + A value marked as 'inline' could not be inlined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1008) + + + + + The value '%s' was marked inline but was not bound in the optimization environment + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1005) + + + + + The value '%s' was marked inline but its implementation makes use of an internal or private function which is not sufficiently accessible + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1004) + + + + + Recursive ValValue %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1010) + + + + + Local value %s not found during optimization + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1006) + + + + + Failed to inline the value '%s' marked 'inline', perhaps because a recursive value was marked 'inline' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1009) + + + + + Unexpected empty long identifier + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1025) + + + + + Multiple types exist called '%s', taking different numbers of generic parameters. Provide a type instantiation to disambiguate the type resolution, e.g. '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1021) + + + + + The instantiation of the generic type '%s' is missing and can't be inferred from the arguments or return type of this member. Consider providing a type instantiation when accessing this type, e.g. '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1022) + + + + + The type '%s' does not contain a field '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1026) + + + + + No constructors are available for the type '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1029) + + + + + This is not a constructor or literal, or a constructor is being used incorrectly + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1024) + + + + + Invalid module/expression/type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1020) + + + + + Invalid field label + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1027) + + + + + Invalid expression '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1028) + + + + + 'global' may only be used as the first name in a qualified path + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1023) + + + + + No Invoke methods found for delegate type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:975) + + + + + More than one Invoke method found for delegate type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:976) + + + + + Could not determine highest installed .NET framework version from Registry keys, using version 2.0 + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1124) + + + + + This construct is for ML compatibility. %s. You can disable this warning by using '--mlcompatibility' or '--nowarn:62'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1111) + + + + + Infix operator member '%s' has %d initial argument(s). Expected a tuple of 2 arguments, e.g. static member (+) (x,y) = ... + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1075) + + + + + Infix operator member '%s' has no arguments. Expected a tuple of 2 arguments, e.g. static member (+) (x,y) = ... + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1074) + + + + + Infix operator member '%s' has extra curried arguments. Expected a tuple of 2 arguments, e.g. static member (+) (x,y) = ... + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1076) + + + + + Identifiers containing '@' are reserved for use in F# code generation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:986) + + + + + The identifier '%s' is reserved for future use by F# + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:987) + + + + + Possible incorrect indentation: this token is offside of context started at position %s. Try indenting this token further or using standard formatting conventions. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1015) + + + + + The '|' tokens separating rules of this pattern match are misaligned by one column. Consider realigning your code or using further indentation. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1016) + + + + + The indentation of this 'in' token is incorrect with respect to the corresponding 'let' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1014) + + + + + Syntax error. Wrong nested #endif, unexpected tokens before it. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1072) + + + + + Unexpected character '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1041) + + + + + This token is reserved for future use + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1062) + + + + + This Unicode encoding is only valid in string literals + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1061) + + + + + TABs are not allowed in F# code unless the #indent \"off\" option is used + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1063) + + + + + This number is outside the allowable range for 32-bit unsigned integers + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1050) + + + + + This number is outside the allowable range for 32-bit signed integers + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1049) + + + + + This number is outside the allowable range for 64-bit unsigned integers + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1052) + + + + + This number is outside the allowable range for 64-bit signed integers + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1051) + + + + + This number is outside the allowable range for 16-bit unsigned integers + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1048) + + + + + This number is outside the allowable range for 16-bit signed integers + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1047) + + + + + This number is outside the allowable range for unsigned native integers + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1054) + + + + + This number is outside the allowable range for signed native integers + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1053) + + + + + This number is outside the allowable range for this integer type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1038) + + + + + This number is outside the allowable range for 8-bit unsigned integers + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1046) + + + + + This number is outside the allowable range for hexadecimal 8-bit signed integers + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1045) + + + + + This number is outside the allowable range for 8-bit signed integers + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1044) + + + + + This number is outside the allowable range for 32-bit floats + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1057) + + + + + This number is outside the allowable range for decimal literals + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1056) + + + + + Character sequences beginning with '?' are no longer permitted as operator names + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1040) + + + + + This is not a valid numeric literal. Sample formats include 4, 0x4, 0b0100, 4L, 4UL, 4u, 4s, 4us, 4y, 4uy, 4.0, 4.0f, 4I. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1058) + + + + + Invalid line number: '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1064) + + + + + Invalid floating point number + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1055) + + + + + This is not a valid character literal + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1060) + + + + + This is not a valid byte literal + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1059) + + + + + Consider using a file with extension '.ml' or '.mli' instead + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1118) + + + + + Identifiers followed by '%s' are reserved for future use + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1043) + + + + + #if directive should be immediately followed by an identifier + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1071) + + + + + #if directive must appear as the first non-whitespace character on a line + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1065) + + + + + #endif has no matching #if + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1069) + + + + + #endif required for #else + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1067) + + + + + #endif directive must appear as the first non-whitespace character on a line + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1070) + + + + + #else has no matching #if + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1066) + + + + + #else directive must appear as the first non-whitespace character on a line + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1068) + + + + + Expected single line comment or end of line + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1073) + + + + + '%s' is not permitted as a character in operator names and is reserved for future use + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1039) + + + + + This byte array literal contains characters that do not encode as a single byte + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1042) + + + + + The type '%s' is required here and is unavailable. You must add a reference to assembly '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:996) + + + + + A reference to the type '%s' in assembly '%s' was found, but the type could not be found in that assembly + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:997) + + + + + A reference to the DLL %s is required by assembly %s. The imported type %s is located in the first assembly and could not be resolved. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:999) + + + + + Internal error or badly formed metadata: not enough type parameters were in scope while importing + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:998) + + + + + An imported assembly uses the type '%s' but that type is not public + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1000) + + + + + PDB files cannot be generated when running on Mono + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1034) + + + + + Unexpected error creating debug information file '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1033) + + + + + Values marked with 'LiteralAttribute' must currently be simple integer, character, Boolean, string or floating point constants + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:849) + + + + + Values marked with 'LiteralAttribute' cannot be mutable + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:848) + + + + + Compiler error: unexpected unrealized value + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:857) + + + + + Unexpected GetSet annotation on a property + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:860) + + + + + Undefined value '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:842) + + + + + This type cannot be used for a literal field + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:859) + + + + + The StructLayout attribute could not be decoded + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:862) + + + + + GenSetStorage: %s was represented as a static method but was not an appropriate lambda expression + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:855) + + + + + The signature for this external function contains type parameters. Constrain the argument and return types to indicate the types of the corresponding C function. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:852) + + + + + Reflected definitions cannot contain uses of the prefix splice operator '%%' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:864) + + + + + Mutable variables cannot escape their method + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:856) + + + + + The MarshalAs attribute could not be decoded + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:851) + + + + + Main module of program is empty: nothing will happen when it is run + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:858) + + + + + Literal fields cannot be set + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:854) + + + + + Label %s not found + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:843) + + + + + Incorrect number of type arguments to local call + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:844) + + + + + The FieldOffset attribute could not be decoded + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:861) + + + + + The FieldOffset attribute can only be placed on members of types marked with the StructLayout(LayoutKind.Explicit) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1121) + + + + + The type '%s' has been marked as having an Explicit layout, but the field '%s' has not been marked with the 'FieldOffset' attribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1113) + + + + + Dynamic invocation of %s is not supported + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:845) + + + + + The DllImport attribute could not be decoded + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:853) + + + + + The DefaultAugmentation attribute could not be decoded + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:863) + + + + + Custom marshallers cannot be specified in F# code. Consider using a C# helper function. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:850) + + + + + This operation involves taking the address of a value '%s' represented using a local variable or other special representation. This is invalid. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:847) + + + + + Taking the address of a literal field is invalid + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:846) + + + + + This file was automatically generated by a call to Goto Definition + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:936) + + + + + If set to true, then all error messages will just return the filled 'holes' delimited by ',,,'s - this is for language-neutral testing (e.g. localization-invariant baselines). + + + + + Prefix flag (' ' or '+') set twice + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:237) + + + + + Precision missing after the '.' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:242) + + + + + Positional specifiers are not permitted in format strings + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:234) + + + + + Missing format specifier + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:235) + + + + + The 'l' or 'L' in this format specifier is unnecessary except for ML compatibility. In F# code you can use %%d, %%x, %%o or %%u instead, which are overloaded to work with all basic integer types. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:245) + + + + + The # formatting modifier is invalid in F# + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:238) + + + + + The 'h' or 'H' in this format specifier is unnecessary. You can use %%d, %%x, %%o or %%u instead, which are overloaded to work with all basic integer types.. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:246) + + + + + '%s' format does not support precision + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:243) + + + + + '%s' flag set twice + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:236) + + + + + '%s' format does not support '0' flag + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:241) + + + + + '%s' does not support prefix '%s' flag + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:247) + + + + + Bad width in format specifier + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:240) + + + + + Bad precision in format specifier + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:239) + + + + + Bad format specifier: '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:248) + + + + + Bad format specifier (after l or L): Expected ld,li,lo,lu,lx or lX. These format specifiers support ML compatibility. In F# code you can use %%d, %%x, %%o or %%u instead, which are overloaded to work with all basic integer types. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:244) + + + + + The record, struct or class field '%s' is not accessible from this code location + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:972) + + + + + This construct is experimental + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:974) + + + + + The event '%s' has a non-standard type. If this event is declared in another CLI language, you may need to access this event using the explicit %s and %s methods for the event. If this event is declared in F#, make the type of the event an instantiation of either 'IDelegateEvent<_>' or 'IEvent<_,_>'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:967) + + + + + System.Environment.Exit did not exit + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:252) + + + + + The treatment of this operator is now handled directly by the F# compiler and its meaning cannot be redefined + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:253) + + + + + Delegates are not allowed to have curried signatures + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:977) + + + + + This type parameter cannot be instantiated to 'Nullable'. This is a restriction imposed in order to ensure the meaning of 'null' in some CLI languages is not confusing when used in conjunction with 'Nullable' values. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:349) + + + + + The type '%s' is not compatible with any of the types %s, arising from the use of a printf-style format string + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:352) + + + + + The type '%s' is not a CLI enum type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:346) + + + + + The type '%s' is not a CLI delegate type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:348) + + + + + Type instantiation length mismatch + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:356) + + + + + Type inference problem too complicated (maximum iteration depth reached). Consider adding further type annotations. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:330) + + + + + The type '%s' has a non-standard delegate type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:347) + + + + + The type '%s' does not support any operators named '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:334) + + + + + The type '%s' does not support the 'equality' constraint because it is a record, union or struct with one or more structural element types which do not support the 'equality' constraint. Either avoid the use of equality with this type, or add the 'StructuralEquality' attribute to the type to determine which field type does not support equality + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:345) + + + + + The type '%s' does not support the 'equality' constraint because it is a function type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:344) + + + + + The type '%s' does not support the 'equality' constraint because it has the 'NoEquality' attribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:343) + + + + + The type '%s' does not support a conversion to the type '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:335) + + + + + The type '%s' does not support the 'comparison' constraint because it is a record, union or struct with one or more structural element types which do not support the 'comparison' constraint. Either avoid the use of comparison with this type, or add the 'StructuralComparison' attribute to the type to determine which field type does not support comparison + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:342) + + + + + The type '%s' does not support the 'comparison' constraint. For example, it does not support the 'System.IComparable' interface + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:341) + + + + + The type '%s' does not support the 'comparison' constraint because it has the 'NoComparison' attribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:340) + + + + + The type '%s' does not have 'null' as a proper value + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:339) + + + + + The declared type parameter '%s' cannot be used here since the type parameter cannot be resolved at compile time + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:328) + + + + + The constraints 'struct' and 'not struct' are inconsistent + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:338) + + + + + The required signature is %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:368) + + + + + Optional arguments not permitted here + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:357) + + + + + No overloads match for method '%s'. The available overloads are shown below (or in the Error List window). + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:383) + + + + + No %s member or object constructor named '%s' takes %d arguments. The named argument '%s' doesn't correspond to any argument or settable return property for any overload. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:381) + + + + + No %s member or object constructor named '%s' takes %d arguments. Note the call to this member also provides %d named arguments. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:380) + + + + + No %s member or object constructor named '%s' takes %d arguments + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:379) + + + + + Method or object constructor '%s' not found + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:382) + + + + + A unique overload for method '%s' could not be determined based on type information prior to this program point. The available overloads are shown below (or in the Error List window). A type annotation may be needed. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:384) + + + + + %s is not an instance method + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:366) + + + + + %s is not a static method + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:365) + + + + + The type '%s' has a method '%s' (full name '%s'), but the method is static + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:336) + + + + + The type '%s' has a method '%s' (full name '%s'), but the method is not static + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:337) + + + + + This method expects a CLI 'params' parameter in this position. 'params' is a way of passing a variable number of arguments to a method in languages such as C#. Consider passing an array for this argument + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:362) + + + + + The member or object constructor '%s' takes %d type argument(s) but is here given %d. The required signature is '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:375) + + + + + The member or object constructor '%s' requires %d argument(s) but is here given %d unnamed and %d named argument(s). The required signature is '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:373) + + + + + The member or object constructor '%s' takes %d argument(s) but is here given %d. The required signature is '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:374) + + + + + The member or object constructor '%s' requires %d additional argument(s). The required signature is '%s'. Some names for missing arguments are %s. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:372) + + + + + The member or object constructor '%s' requires %d argument(s). The required signature is '%s'. Some names for missing arguments are %s. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:371) + + + + + The member or object constructor '%s' requires %d additional argument(s). The required signature is '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:370) + + + + + The member or object constructor '%s' requires %d argument(s). The required signature is '%s'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:369) + + + + + The member or object constructor '%s' does not take %d argument(s). An overload was found taking %d arguments. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:378) + + + + + The member or object constructor '%s' taking %d arguments are not accessible from this code location. All accessible versions of method '%s' take %d arguments. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:376) + + + + + %s is not a static member + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:358) + + + + + %s is not an instance member + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:359) + + + + + The member or object constructor '%s' is not %s. Private members may only be accessed from within the declaring type. Protected members may only be accessed from an extending type and cannot be accessed from inner lambda expressions. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:364) + + + + + The member or object constructor '%s' is not %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:363) + + + + + The member or object constructor '%s' has no argument or settable return property '%s'. %s. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:367) + + + + + This indexer expects %d arguments but is here given %d + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:332) + + + + + Incorrect generic instantiation. No %s member named '%s' takes %d generic arguments. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:377) + + + + + A generic construct requires that the type '%s' is an unmanaged type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:351) + + + + + A generic construct requires that the type '%s' is a CLI or F# struct type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:350) + + + + + A generic construct requires that the type '%s' have reference semantics, but it does not, i.e. it is a struct + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:353) + + + + + A generic construct requires that the type '%s' have a public default constructor + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:355) + + + + + A generic construct requires that the type '%s' be non-abstract + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:354) + + + + + Expected arguments to an instance member + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:331) + + + + + Expecting a type supporting the operator '%s' but given a function type. You may be missing an argument to a function. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:333) + + + + + This code is less generic than indicated by its annotations. A unit-of-measure specified using '_' has been determined to be '1', i.e. dimensionless. Consider making the code generic, or removing the use of '_'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:329) + + + + + The argument types don't match + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:361) + + + + + Argument length mismatch + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:360) + + + + + Quotations cannot contain expressions that set union case fields + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:315) + + + + + Quotations cannot contain expressions that set fields in exception values + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:316) + + + + + Quotations cannot contain expressions that require byref pointers + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:317) + + + + + Quotations cannot contain expressions that fetch union case indexes + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:314) + + + + + Quotations cannot contain this kind of type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:322) + + + + + Quotations cannot contain this kind of pattern match + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:320) + + + + + Quotations cannot contain this kind of constant + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:319) + + + + + Quotations cannot contain expressions that fetch static fields + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:311) + + + + + Quotations cannot contain object expressions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:309) + + + + + Quotations cannot contain literal byte arrays + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:323) + + + + + Quotations cannot contain inline assembly code or pattern matching on arrays + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:312) + + + + + Quotations cannot contain function declarations that are inferred or declared to be generic. Consider adding some type constraints to make this a valid quoted expression. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:308) + + + + + Quotations cannot contain uses of generic expressions + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:307) + + + + + Quotations cannot contain descending for loops + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:313) + + + + + Quotations cannot contain array pattern matching + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:321) + + + + + Quotations cannot contain expressions that take the address of a field + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:310) + + + + + Quotations cannot contain expressions that make member constraint calls, or uses of operators that implicitly resolve to a member constraint call + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:318) + + + + + Inner generic functions are not permitted in quoted expressions. Consider adding some type constraints until this function is no longer generic. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:324) + + + + + The variable '%s' is bound in a quotation but is used as part of a spliced expression. This is not permitted since it may escape its scope. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:306) + + + + + The variable '%s' is used in an invalid way + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:261) + + + + + The type of a field using the 'DefaultValue' attribute must admit default initialization, i.e. have 'null' as a proper value or be a struct type whose fields all admit default initialization. You can use 'DefaultValue(false)' to disable this check + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:301) + + + + + The value '%s' is unused + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1087) + + + + + The recursive object reference '%s' is unused. The presence of a recursive object reference adds runtime initialization checks to members in this and derived types. Consider removing this recursive object reference. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1088) + + + + + default augmentation of the union case + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:286) + + + + + compiled form of the union case + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:285) + + + + + The type '%s' is less accessible than the value, member or type '%s' it is used in + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:262) + + + + + 'System.Void' can only be used as 'typeof<System.Void>' in F# + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:263) + + + + + Expression-splicing operators may only be used within quotations + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:266) + + + + + A method return type would contain byrefs which is not permitted + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:278) + + + + + [<ReflectedDefinition>] terms cannot contain uses of the prefix splice operator '%%' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:283) + + + + + A protected member is called or 'base' is being used. This is only allowed in the direct implementation of members since they could escape their object scope. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:257) + + + + + Name clash. The property '%s' has the same name as a method in this type. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:287) + + + + + The property '%s' has the same name as another property in this type, but one takes indexer arguments and the other does not. You may be missing an indexer argument to one of your properties. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:289) + + + + + Object constructors cannot directly use try/with and try/finally prior to the initialization of the object. This includes constructs such as 'for x in ...' that may elaborate to uses of these constructs. This is a limitation imposed by Common IL. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:272) + + + + + First-class uses of the expression-splicing operator are not permitted + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:267) + + + + + First-class uses of the 'reraise' function is not permitted + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:269) + + + + + First-class uses of the address-of operators are not permitted + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:268) + + + + + The type abbreviation contains byrefs. This is not permitted by F#. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:302) + + + + + The byref typed value '%s' cannot be used at this point + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:270) + + + + + A byref typed value would be stored here. Top-level let-bound byref values are not permitted. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:282) + + + + + The address of the static field '%s' cannot be used at this point + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:274) + + + + + The address of the variable '%s' cannot be used at this point + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:273) + + + + + The address of an array element cannot be used at this point + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:276) + + + + + The address of the field '%s' cannot be used at this point + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:275) + + + + + The mutable variable '%s' is used in an invalid way. Mutable variables cannot be captured by closures. Consider eliminating this use of mutation or using a heap-allocated mutable reference cell via 'ref' and '!'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:259) + + + + + This type implements or inherits the same interface at different generic instantiations '%s' and '%s'. This is not permitted in this version of F#. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:300) + + + + + The member '%s' is used in an invalid way. A use of '%s' has been inferred prior to its definition at or near '%s'. This is an invalid forward reference. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:281) + + + + + 'base' values may only be used to make direct calls to the base implementations of overridden members + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:271) + + + + + Invalid custom attribute value (not a constant or literal) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:279) + + + + + The property '%s' has a getter and a setter that do not match. If one is abstract then the other must be as well. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:288) + + + + + The type of a first-class function cannot contain byrefs + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:277) + + + + + A type instantiation involves a byref type. This is not permitted by the rules of Common IL. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:264) + + + + + Calls to 'reraise' may only occur directly in a handler of a try-with + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:265) + + + + + A function labeled with the 'EntryPointAttribute' attribute must be the last declaration in the last file in the compilation sequence, and can only be used when compiling to a .exe + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:284) + + + + + Duplicate property. The property '%s' has the same name and signature as another property in this type once tuples, functions and/or units of measure are erased. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:297) + + + + + Duplicate property. The property '%s' has the same name and signature as another property in this type. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:296) + + + + + Duplicate method. The method '%s' has the same name and signature as another method in this type once tuples, functions and/or units of measure are erased. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:293) + + + + + Duplicate method. The abstract method '%s' has the same name and signature as an abstract method in an inherited type once tuples, functions and/or units of measure are erased. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:299) + + + + + Duplicate method. The abstract method '%s' has the same name and signature as an abstract method in an inherited type. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:298) + + + + + The method '%s' has curried arguments but has the same name as another method in this type. Methods with curried arguments cannot be overloaded. Consider using a method taking tupled arguments. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:294) + + + + + Duplicate method. The method '%s' has the same name and signature as another method in this type. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:292) + + + + + Methods with curried arguments cannot declare 'out', 'ParamArray', 'optional' or 'byref' arguments + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:295) + + + + + A type would store a byref typed value. This is not permitted by Common IL. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:290) + + + + + The byref-typed variable '%s' is used in an invalid way. Byrefs cannot be captured by closures or passed to inner functions. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:258) + + + + + The 'base' keyword is used in an invalid way. Base calls cannot be used in closures. Consider using a private member to make base calls. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:260) + + + + + The attribute type '%s' has 'AllowMultiple=false'. Multiple instances of this attribute cannot be attached to a single language element. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:280) + + + + + Unrecognized option: '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:60) + + + + + ParseInput: unknown file suffix for '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:41) + + + + + The non-generic type '%s' does not expect any type arguments, but here is given %d type argument(s) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:17) + + + + + The signature file '%s' does not have a corresponding implementation file. If an implementation file exists then check the 'module' and 'namespace' declarations in the signature and implementation files match. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:57) + + + + + A signature for the file or module '%s' has already been specified + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:54) + + + + + The search directory '%s' could not be found + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:27) + + + + + The file '%s' is a CLI 1.x version of mscorlib. F# requires CLI version 2.0 or greater. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:32) + + + + + Microsoft (R) F# 2.0 Compiler build %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:21) + + + + + Problem with filename '%s': %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:22) + + + + + The '--pdb' option requires the '--debug' option to be used + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:25) + + + + + Option requires parameter: %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:42) + + + + + No inputs specified + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:23) + + + + + This file contains multiple declarations of the form 'module SomeNamespace.SomeModule'. Only one declaration of this form is permitted in a file. Change your file to use an initial namespace declaration and/or use 'module ModuleName = ...' to define your modules. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:40) + + + + + Multiple references to '%s.dll' are not permitted + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:31) + + + + + Files in libraries or multiple-file applications must begin with a namespace or module declaration, e.g. 'namespace SomeNamespace.SubNamespace' or 'module SomeNamespace.SomeModule' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:39) + + + + + The referenced or default base CLI library 'mscorlib' is binary-incompatible with the referenced library '%s'. Consider recompiling the library or making an explicit reference to a version of this library that matches the CLI version you are using. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:34) + + + + + The referenced or default base CLI library 'mscorlib' is binary-incompatible with the referenced F# core library '%s'. Consider recompiling the library or making an explicit reference to a version of this library that matches the CLI version you are using. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:36) + + + + + The output name extension doesn't match the options used. If '-a' or '--target:library' is used the output file name must end with '.dll', if '--target:module' is used the output extension must be '.netmodule', otherwise '.exe'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:24) + + + + + Invalid warning number '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:18) + + + + + Invalid version string '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:19) + + + + + Invalid version file '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:20) + + + + + The file extension of '%s' is not recognized. Source files must have extension .fs, .fsi, .fsx, .fsscript, .ml or .mli. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:44) + + + + + The search directory '%s' is invalid + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:26) + + + + + Unrecognized privacy setting '%s' for managed resource, valid options are 'public' and 'private' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:30) + + + + + Invalid module or namespace name + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:61) + + + + + Invalid directive. Expected '#time', '#time \"on\"' or '#time \"off\"'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:52) + + + + + Invalid directive. Expected '#r \"<file-or-assembly>\"'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:50) + + + + + Invalid directive. Expected '#load \"<file>\" ... \"<file>\"'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:51) + + + + + Invalid directive. Expected '#I \"<path>\"'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:49) + + + + + '%s' is not a valid filename + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:28) + + + + + '%s' is not a valid assembly name + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:29) + + + + + The declarations in this file will be placed in an implicit module '%s' based on the file name '%s'. However this is not a valid F# identifier, so the contents will not be accessible from other files. Consider renaming the file or adding a 'module' or 'namespace' declaration at the top of the file. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:38) + + + + + An implementation of file or module '%s' has already been given. Compilation order is significant in F# because of type inference. You may need to adjust the order of your files to place the signature file before the implementation. In Visual Studio files are type-checked in the order they appear in the project file, which can be edited manually or adjusted using the solution explorer. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:55) + + + + + An implementation of the file or module '%s' has already been given + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:56) + + + + + When mscorlib.dll or FSharp.Core.dll is explicitly referenced the %s option must also be passed + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:62) + + + + + FSharp.Core.sigdata not found alongside FSharp.Core + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:64) + + + + + File '%s' not found alongside FSharp.Core + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:66) + + + + + Error opening binary file '%s': %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:47) + + + + + Directives inside modules are ignored + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:53) + + + + + The F#-compiled DLL '%s' needs to be recompiled to be used with this version of F# + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:48) + + + + + Did not expect to find sigdata resource in FSharp.Core.dll + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:63) + + + + + Did not expect to find optdata resource in FSharp.Core.dll + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:65) + + + + + Could not resolve assembly '%s' required by '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:46) + + + + + Could not resolve assembly '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:45) + + + + + Could not read version from mscorlib.dll + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:33) + + + + + Source file '%s' could not be found + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:43) + + + + + The file extensions '.ml' and '.mli' are for ML compatibility + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1117) + + + + + Unable to read assembly '%s' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:35) + + + + + Assembly resolution failure at or near this location + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:37) + + + + + '%s' is not a valid integer argument + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:58) + + + + + '%s' is not a valid floating point argument + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:59) + + + + + A type cannot have both the 'ReferenceEquality' and 'StructuralEquality' or 'StructuralComparison' attributes + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:223) + + + + + The 'StructuralEquality' attribute must be used in conjunction with the 'NoComparison' or 'StructuralComparison' attributes + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:222) + + + + + The 'StructuralComparison' attribute must be used in conjunction with the 'StructuralEquality' attribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:221) + + + + + A type with attribute 'ReferenceEquality' cannot have an explicit implementation of 'Object.Equals(obj)', 'System.IEquatable<_>' or 'System.Collections.IStructuralEquatable' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:225) + + + + + Only record, union, exception and struct types may be augmented with the 'ReferenceEquality', 'StructuralEquality' and 'StructuralComparison' attributes + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:224) + + + + + The 'ReferenceEquality' attribute cannot be used on structs. Consider using the 'StructuralEquality' attribute instead, or implement an override for 'System.Object.Equals(obj)'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:218) + + + + + The 'NoEquality' attribute must be used in conjunction with the 'NoComparison' attribute + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:220) + + + + + A type with attribute 'NoEquality' should not usually have an explicit implementation of 'Object.Equals(obj)'. Disable this warning if this is intentional for interoperability purposes + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:228) + + + + + A type with attribute 'NoComparison' should not usually have an explicit implementation of 'System.IComparable', 'System.IComparable<_>' or 'System.Collections.IStructuralComparable'. Disable this warning if this is intentional for interoperability purposes + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:229) + + + + + This type uses an invalid mix of the attributes 'NoEquality', 'ReferenceEquality', 'StructuralEquality', 'NoComparison' and 'StructuralComparison' attributes + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:219) + + + + + A type with attribute 'CustomEquality' must have an explicit implementation of at least one of 'Object.Equals(obj)', 'System.IEquatable<_>' or 'System.Collections.IStructuralEquatable' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:226) + + + + + The 'CustomEquality' attribute must be used in conjunction with the 'NoComparison' or 'CustomComparison' attributes + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:230) + + + + + A type with attribute 'CustomComparison' must have an explicit implementation of at least one of 'System.IComparable' or 'System.Collections.IStructuralComparable' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:227) + + + + + Error while parsing embedded IL type + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:212) + + + + + Error while parsing embedded IL + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:211) + + + + + Invalid expression on left of assignment + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:214) + + + + + This indexer notation has been removed from the F# language + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:213) + + + + + .NET Framework + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:960) + + + + + Global Assembly Cache + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:961) + + + + + Found by AssemblyFolders registry key + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:958) + + + + + Found by AssemblyFoldersEx registry key + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:959) + + + + + Active pattern '%s' is not a function + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1119) + + + + + Active pattern '%s' has a result type containing type variables that are not determined by the input. The common cause is a when a result case is not mentioned, e.g. 'let (|A|B|) (x:int) = A x'. This can be fixed with a type constraint, e.g. 'let (|A|B|) (x:int) : Choice<int,unit> = A x' + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:1120) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nOne is virtual and the other isn't + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:120) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe types differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:112) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nOne is static and the other isn't + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:119) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe compiled representation of this method is as a static member but the signature indicates its compiled representation is as an instance member + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:125) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe respective type parameter counts differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:111) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nOne is marked as an override and the other isn't + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:123) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nOne is a type function and the other is not. The signature requires explicit type parameters if they are present in the implementation. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:110) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nOne is a constructor/property and the other is not + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:124) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe names differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:104) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe literal constant values and/or attributes differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:109) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe compiled representation of this method is as an instance member, but the signature indicates its compiled representation is as a static member + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:126) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe inline flags differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:108) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe number of generic parameters in the signature and implementation differ (the signature declares %s but the implementation declares %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:115) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe generic parameters in the signature and implementation have different kinds. Perhaps there is a missing [<Measure>] attribute. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:116) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nOne is final and the other isn't + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:122) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nOne is an extension member and the other is not + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:113) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe CLI member names differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:118) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe display names differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:106) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe compiled names differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:105) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe mutability attributes differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:103) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nAn arity was not inferred for this value + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:114) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe arities in the signature and implementation differ. The signature specifies that '%s' is function definition or lambda expression accepting at least %s argument(s), but the implementation is a computed function value. To declare that a computed function value is a permitted implementation simply parenthesize its type in the signature, e.g.\n\tval %s: int -> (int -> int)\ninstead of\n\tval %s: int -> int -> int. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:117) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nThe accessibility specified in the signature is more than that specified in the implementation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:107) + + + + + Module '%s' contains\n %s \nbut its signature specifies\n %s \nOne is abstract and the other isn't + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:121) + + + + + Call this method once to validate that all known resources are valid; throws if not + + + + + The module contains the constructor\n %s \nbut its signature specifies\n %s \nThe types of the fields differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:161) + + + + + The module contains the constructor\n %s \nbut its signature specifies\n %s \nThe names differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:159) + + + + + The module contains the constructor\n %s \nbut its signature specifies\n %s \nThe respective number of data fields differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:160) + + + + + The module contains the constructor\n %s \nbut its signature specifies\n %s \nthe accessibility specified in the signature is more than that specified in the implementation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:162) + + + + + Invalid recursive reference to an abstract slot + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:966) + + + + + The module contains the field\n %s \nbut its signature specifies\n %s \nThe types differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:168) + + + + + The module contains the field\n %s \nbut its signature specifies\n %s \nThe 'static' modifiers differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:165) + + + + + The module contains the field\n %s \nbut its signature specifies\n %s \nThe names differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:163) + + + + + The module contains the field\n %s \nbut its signature specifies\n %s \nThe 'mutable' modifiers differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:166) + + + + + The module contains the field\n %s \nbut its signature specifies\n %s \nThe 'literal' modifiers differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:167) + + + + + The module contains the field\n %s \nbut its signature specifies\n %s \nthe accessibility specified in the signature is more than that specified in the implementation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:164) + + + + + The exception definitions are not compatible because the exception abbreviations in the signature and implementation differ. The module contains the exception definition\n %s \nbut its signature specifies\n\t%s. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:187) + + + + + The exception definitions are not compatible because a CLI exception mapping is being hidden by a signature. The exception mapping must be visible to other modules. The module contains the exception definition\n %s \nbut its signature specifies\n\t%s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:184) + + + + + The exception definitions are not compatible because the order of the fields is different in the signature and implementation. The module contains the exception definition\n %s \nbut its signature specifies\n\t%s. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:191) + + + + + The exception definitions are not compatible because the field '%s' was required by the signature but was not specified by the implementation. The module contains the exception definition\n %s \nbut its signature specifies\n\t%s. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:189) + + + + + The exception definitions are not compatible because the field '%s' was present in the implementation but not in the signature. The module contains the exception definition\n %s \nbut its signature specifies\n\t%s. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:190) + + + + + The exception definitions are not compatible because the exception declarations differ. The module contains the exception definition\n %s \nbut its signature specifies\n\t%s. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:188) + + + + + The exception definitions are not compatible because the CLI representations differ. The module contains the exception definition\n %s \nbut its signature specifies\n\t%s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:185) + + + + + The exception definitions are not compatible because the exception abbreviation is being hidden by the signature. The abbreviation must be visible to other CLI languages. Consider making the abbreviation visible in the signature. The module contains the exception definition\n %s \nbut its signature specifies\n\t%s. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:186) + + + + + The %s definitions in the signature and implementation are not compatible because the types have different base types + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:139) + + + + + The %s definitions in the signature and implementation are not compatible because a type representation is being hidden by a signature + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:145) + + + + + The %s definitions in the signature and implementation are not compatible because the types are of different kinds + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:146) + + + + + The %s definitions in the signature and implementation are not compatible because the signature says this type may use nulls as an extra value but the implementation does not + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:134) + + + + + The %s definitions in the signature and implementation are not compatible because the signature says this type may use nulls as a representation but the implementation does not + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:133) + + + + + The %s definitions in the signature and implementation are not compatible because the signature is an abstract class but the implementation is not. Consider adding the [<AbstractClass>] attribute to the implementation. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:138) + + + + + The %s definitions in the signature and implementation are not compatible because the signature defines the %s '%s' but the implementation does not (or does, but not in the same order) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:141) + + + + + The %s definitions in the signature and implementation are not compatible because the signature declares a %s while the implementation declares a %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:155) + + + + + The %s definitions in the signature and implementation are not compatible because the signature has an abbreviation while the implementation does not + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:158) + + + + + The %s definitions in the signature and implementation are not compatible because the representations differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:148) + + + + + The %s definitions in the signature and implementation are not compatible because the respective type parameter counts differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:128) + + + + + The %s definitions in the signature and implementation are not compatible because the number of %ss differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:140) + + + + + The %s definitions in the signature and implementation are not compatible because the names differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:127) + + + + + The %s definitions in the signature and implementation are not compatible because the signature requires that the type supports the interface %s but the interface has not been implemented + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:130) + + + + + The %s definitions in the signature and implementation are not compatible because the implementation type is sealed but the signature implies it is not. Consider adding the [<Sealed>] attribute to the signature. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:135) + + + + + The %s definitions in the signature and implementation are not compatible because the implementation says this type may use nulls as an extra value but the signature does not + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:132) + + + + + The %s definitions in the signature and implementation are not compatible because the implementation says this type may use nulls as a representation but the signature does not + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:131) + + + + + The %s definitions in the signature and implementation are not compatible because the implementation type is not sealed but signature implies it is. Consider adding the [<Sealed>] attribute to the implementation. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:136) + + + + + The %s definitions in the signature and implementation are not compatible because the implementation is an abstract class but the signature is not. Consider adding the [<AbstractClass>] attribute to the signature. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:137) + + + + + The %s definitions in the signature and implementation are not compatible because the implementation defines a struct but the signature defines a type with a hidden representation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:143) + + + + + The %s definitions in the signature and implementation are not compatible because the implementation defines the %s '%s' but the signature does not (or does, but not in the same order) + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:142) + + + + + The %s definitions in the signature and implementation are not compatible because the IL representations differ + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:147) + + + + + The %s definitions in the signature and implementation are not compatible because the field %s was present in the implementation but not in the signature + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:149) + + + + + The %s definitions in the signature and implementation are not compatible because the field %s was required by the signature but was not specified by the implementation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:151) + + + + + The %s definitions in the signature and implementation are not compatible because the order of the fields is different in the signature and implementation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:150) + + + + + The %s definitions in the signature and implementation are not compatible because the field %s was present in the implementation but not in the signature. Struct types must now reveal their fields in the signature for the type, though the fields may still be labelled 'private' or 'internal'. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:152) + + + + + The %s definitions in the signature and implementation are not compatible because a CLI type representation is being hidden by a signature + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:144) + + + + + The %s definitions in the signature and implementation are not compatible because the accessibility specified in the signature is more than that specified in the implementation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:129) + + + + + The %s definitions in the signature and implementation are not compatible because the abstract member '%s' was present in the implementation but not in the signature + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:154) + + + + + The %s definitions in the signature and implementation are not compatible because the abstract member '%s' was required by the signature but was not specified by the implementation + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:153) + + + + + The %s definitions in the signature and implementation are not compatible because the abbreviations differ: %s versus %s + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:156) + + + + + The %s definitions in the signature and implementation are not compatible because an abbreviation is being hidden by a signature. The abbreviation must be visible to other CLI languages. Consider making the abbreviation visible in the signature. + (Originally from C:\fsharp\staging\src\fsharp\FSComp.txt:157) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Convert string into Option string where null and String.Empty result in None + + + + + + + + + + + + + + Get the System.Reflection.Assembly object for the assembly + + + + + Holds the full qualified assembly name + + + + + Get the object representing the F# core library (FSharp.Core.dll) for the running program + + + + + A handle to the full specification of the contents of the module contained in this Assembly + + + + + A hint as to where does the code for the CCU live (e.g what was the tcConfig.implicitIncludeDir at compilation time for this DLL?) + + + + + Return the System.Reflection.Assembly object for the assembly + + + + + This is one way of starting the loading process off. + + + + + This is one way of starting the loading process off. Dependencies are automatically + resolved by calling System.Reflection.Assembly.Load. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Get the XML documentation signature for the entity + + + + + Indicates the type prefers the "tycon<a,b>" syntax for display etc. + + + + + Get the cases of a discriminated union + + + + + Get the declared accessibility of the representation, not taking signatures into account + + + + + Get the System.Type for the type + + Raises InvalidOperationException if the type is an abbreviation or has an assembly code representation. + + + + + Get the System.Reflection.Assembly for the type + + May raise an exception if an assembly load fails + + + + + Get the fields of the class, struct or enum + + + + + Get the fully qualified name of the type or module + + + + + + + + Get the namespace containing the type or module, if any + + + + + Properties, methods etc. with implementations, also values in a module + + + + + Get the name of the type or module, possibly with `n mangling + + + + + Indicates the entity is a struct or enum + + + + + Indicates the entity is union type + + + + + Indicates the entity is record type + + + + + Indicates the entity is an F# module definition + + + + + Indicates the entity is a measure definition + + + + + If true, then this is a reference to something in some .NET assembly from another .NET language + + + + + Indicates an F# exception declaration + + + + + Indicates the entity is a measure, type or exception abbreviation + + + + + Interface implementations - boolean indicates compiler-generated + + + + + Indicates that a module is compiled to a class with the given mangled name. The mangling is reversed during lookup + + + + + Indicates the type is implemented through a mapping to IL assembly code. THis is only + true for types in FSharp.Core.dll + + + + + Get the generic parameters, possibly including unit-of-measure parameters + + + + + Get the name of the type or module as displayed in F# code + + + + + Get the entity containing the type or module, if any + + + + + Get the declaration location for the type constructor + + + + + Get the compiled name of the type or module, possibly with `n mangling. This is identical to LogicalName + unless the CompiledName attribute is used. + + + + + Base type, if any + + + + + Get the declared attributes for the type + + + + + Get the declared accessibility of the type + + + + + + + + Return the FSharpEntity corresponding to a .NET type + + + + + Represents an F# type or module + + + + + + + + + + + Get the documentation for the type parameter. + + + + + Get the name of the generic parameter + + + + + Indicates if this is a statically resolved type variable + + + + + Indicates if this is a measure variable + + + + + Get the range of the generic parameter + + + + + Get the declared or inferred constraints for the type parameter + + + + + Get the declared attributes of the type parameter. + + + + + + + + + + + + + + + + + + + + + + + + + + Indicates a constraint that a type is an unmanaged type + + + + + Indicates a constraint that a type has a 'null' value + + + + + Indicates a constraint that a type is a simple choice between one of the given ground types. Used by printf format strings. + + + + + Indicates a constraint that a type has a parameterless constructor + + + + + Indicates a constraint that a type is a reference type + + + + + Indicates a constraint that a type is a non-Nullable value type + + + + + Indicates a constraint that a type has a member with the given signature + + + + + Indicates a constraint that a type supports F# generic equality + + + + + Indicates a constraint that a type is an enum with the given underlying + + + + + Indicates a constraint that a type is a delegate from the given tuple of args to the given return type + + + + + Indicates a default value for an inference type variable should it be netiher generalized nor solved + + + + + Indicates a constraint that a type supports F# generic comparison + + + + + Indicates a constraint that a type is a subtype of the given type + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Indictes the value is inlined but the code for the function still exists, e.g. to satisfy interfaces on objects, but that it is also always inlined + + + + + + + + + + + + + + + + + + + + XML documentation signature for the value. + + + + + Get the full type of the member or value when used as a first class value + + + + + + + + Get the reflection object for this member + + + + + Get the logical name of the member + + + + + Get the logical enclosing entity, which for an extension member is type being extended + + + + + Indicates if this is an F# type function + + + + + Indicates if this is a setter method for a property + + + + + Indicates if this is a mutable value + + + + + Indicates if this is a module or member value + + + + + Indicates if this is a member, including extension members? + + + + + Indicates if this is an instance member, when seen from F#? + + + + + Indicates if this is an implicit constructor? + + + + + Indicates if this is a getter method for a property + + + + + Indicates if this is an extension member? + + + + + Indicates if this is an abstract member? + + + + + Indicates if this is a compiler generated value + + + + + Indicates if this value or member is an F# active pattern + + + + + Get a result indicating if this is a must-inline value + + + + + Get the typars of the member or value + + + + + + + + Get the name as presented in F# error messages and documentation + + + + + Get the declaration location of the member or value + + + + + + + + Get the member name in compiled code + + + + + Custom attributes attached to the value. These contain references to other values (i.e. constructors in types). Mutable to fixup + these value references after copying a colelction of values. + + + + + How visible is this? + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Get the XML documentation signature for the field + + + + + Get the type of the field, w.r.t. the generic parameters of the enclosing type constructor + + + + + Get the attributes attached to generated property + + + + + Get the name of the field + + + + + Indicates a static field + + + + + Is the field declared in F#? + + + + + Indicates a compiler generated field, not visible to Intellisense or name resolution + + + + + Get the attributes attached to generated field + + + + + Get the declaration location of the field + + + + + Indicates the declared visibility of the field, not taking signatures into account + + + + + + + + + + + + + + Get the named entity for a type constructed using a named entity + + + + + Indicates the type is a tuple type. The GenericArguments property returns the elements of the tuple type. + + + + + Indicates the type is constructed using a named entity + + + + + Indicates the type is a variable type, whether declared, generalized or an inference type parameter + + + + + Indicates the type is a function type. The GenericArguments property returns the domain and range of the function type. + + + + + Get the index for a generic parameter type + + + + + Get the generic parameter data for a generic parameter type + + + + + Get the generic arguments for a tuple type, a function type or a type constructed using a named entity + + + + + + + + + + + + + + Get the XML documentation signature for the case + + + + + Get type constructed by the case. Normally exactly the type of the enclosing type, sometimes an abbreviation of it + + + + + Get the name of the case + + + + + Get the data carried by the case. + + + + + Get the range of the name of the case + + + + + Gete the name of the case in generated IL code + + + + + Get the attributes for the case, attached to the generated static method to make instances of the case + + + + + Indicates the declared visibility of the union constructor, not taking signatures into account + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Note this operation is O(n) anyway, so executing lastElements() here is OK + + + + + Note this operation is O(1), unless a push happens, which is rare + + + + + + + + + + + + + + + + + Iterable functional collection with O(1) append-1 time. Useful for data structures where elements get added at the + end but the collection must occadionally be iterated. Iteration is slower and may allocate because + a suffix of elements is stored in reverse order. + + The type doesn't support structural hashing or comparison. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + keyed first on namespace then on type name. The namespace is often a unique key for a given type map. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + The explicit offset in bytes when explicit layout is used. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Index table by name and arity. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + The type instantiation if the type is generic + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Calling conventions. These are used in method pointer types. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Global state: table of all assembly references keyed by AssemblyRefData + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + This is used to store event, property and field maps. + + Review: this is not such a great data structure. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Global State. All namespace splits + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + A little ugly, but the idea is that if a data structure does not + contain lazy values then we don't add laziness. So if the thing to map + is already evaluated then immediately apply the function. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + The assumptions that need to be fixed up + + + + + The data that uses a collection of CcuThunks internally + + + + + Like Fixup but loader may return None, in which case there is no fixup. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + This field holds either the function to run or a PPLazyFailure object recording the exception raised + from running the function. It is null if the thunk has been evaluated successfully. + + + + + This field holds the result of a successful computation. It's initial value is Unchecked.defaultof + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Treat a list of key-value pairs as a lookup collection. + This function returns true if two keys are the same according to the predicate + function passed in. + + + + + Treat a list of key-value pairs as a lookup collection. + This function looks up a value based on a match from the supplied + predicate function. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Try to chop "get_" or "set_" from a string + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Specifies the compiled representations of type and exception definitions. + Computed and cached by later phases (never computed type checking). Cached at + type and exception definitions. Not pickled. Cache an optional ILType object for + non-generic types + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + A representation of a method in an object expression. + Note: Methods associated with types are represented as val declarations + Note: We should probably use val_specs for object expressions, as then the treatment of members + in object expressions could be more unified with the treatment of members in types + + + + + + + + + + + + + + A call to a base method, e.g. 'base.OnPaint(args)' + + + + + A call to a constructor, e.g. 'new C() = new C(3)' + + + + + A call to a constructor, e.g. 'inherit C()' + + + + + A normal use of a value + + + + + Indicates a use of a value represents a call to a method that may require + a .NET 2.0 constrained call. A constrained call is only used for calls where + + + + + + + + let res = a in b;res + + + + + a ; b + + + + + + + + In C syntax this is: *localv_ptr = e + + + + + In C syntax this is: localv = e , note == *(&localv) = e == LGetAddr; LByrefSet + + + + + In C syntax this is: *localv_ptr + + + + + In C syntax this is: &localv + + + + + + + + Evaluate start once and end multiple times, loop up + + + + + Evaluate start and end once, loop down + + + + + Evaluate start and end once, loop up + + + + + + + + + + + + + + + + + + + + IL method calls + + + + + Operation nodes represnting C-style operations on byrefs and mutable vals (l-values) + + + + + Pseudo method calls. This is used for overloaded operations like op_Addition. + + + + + + + + Represents a "rethrow" operation. May not be rebound, or used outside of try-finally, expecting a unit argument + + + + + Conversion node, compiled via type-directed translation or to box/unbox + + + + + generate a ldflda on an 'a ref. + + + + + IL assembly code - type list are the types pushed on the stack + + + + + An operation representing a field-get from an F# tuple value. + + + + + An operation representing a field-set on an F# exception value. + + + + + An operation representing a field-get from an F# exception value. + + + + + An operation representing a field-get from a union value. THe value is not assumed to have been proven to be of the corresponding union case. + + + + + An operation representing a field-get from a union value, where that value has been proven to be of the corresponding union case. + + + + + An operation representing a coercion that proves a union value is of a particular union case. THis is not a test, its + simply added proof to enable us to generate verifiable code for field access on union types + + + + + An operation representing getting an integer tag for a union value representing the union case number + + + + + An operation representing getting the address of a record field + + + + + An operation representing getting a record field + + + + + An operation representing setting a record field + + + + + Construct a record or object-model value. The ValRef is for self-referential class constructors, otherwise + it indicates that we're in a constructor and the purpose of the expression is to + fill in the fields of a pre-created but uninitialized object, and to assign the initialized + version of the object into the optional mutable cell pointed to be the given value. + + + + + An operation representing a lambda-encoded try/finally + + + + + An operation representing a lambda-encoded try/catch + + + + + An operation representing a lambda-encoded for loop + + + + + An operation representing a lambda-encoded while loop. The special while loop marker is used to mark compilations of 'foreach' expressions + + + + + + + + Constant bytes, but a new mutable blob is generated each time the construct is executed + + + + + An operation representing the creation of an array value + + + + + An operation representing the creation of a tuple value + + + + + An operation representing the creation of an exception value using an F# exception declaration + + + + + An operation representing the creation of a union value of the particular union case + + + + + + + + Normal record construction + + + + + We're in a constructor. The purpose of the record expression is to + fill in the fields of a pre-created but uninitialized object + + + + + This ModuleOrNamespace that represents the compilation of a module as a class. + The same set of tycons etc. are bound in the ModuleOrNamespace as in the ModuleOrNamespaceExpr + This is the body of the module/namespace + + + + + + + + A named module-or-namespace-fragment definition + + + + + Indicates the module fragment is a 'rec' definition of types, values and modules + + + + + Indicates the module fragment is an evaluation of expression for side-effects + + + + + Indicates the module fragment is a 'let' definition + + + + + Indicates the module fragment is made of several module fragments in succession + + + + + Indicates the module is a module with a signature + + + + + The module_typ is a binder. However it is not used in the ModuleOrNamespaceExpr: it is only referenced from the 'outside' + The contents of a module-or-namespace-fragment definition + + + + + + + + A type for a module-or-namespace-fragment and the actual definition of the module-or-namespace-fragment + + + + + Typechecking residue: A TExpr_link occurs for every use of a recursively bound variable. While type-checking + the recursive bindings a dummy expression is stored in the mutable reference cell. + After type checking the bindings this is replaced by a use of the variable, perhaps at an + appropriate type instantiation. These are immediately eliminated on subsequent rewrites. + + + + + Typechecking residue: Indicates a free choice of typars that arises due to + minimization of polymorphism at let-rec bindings. These are + resolved to a concrete instantiation on subsequent rewrites. + + + + + + + + An intrinsic applied to some (strictly evaluated) arguments + A few of intrinsics (TOp_try, TOp_while, TOp_for) expect arguments kept in a normal form involving lambdas + + + + + If we statically know some infomation then in many cases we can use a more optimized expression + This is primarily used by terms in the standard library, particularly those implementing overloaded + operators. + + + + + Matches are a more complicated form of "let" with multiple possible destinations + and possibly multiple ways to get to each destination. + The first mark is that of the expression being matched, which is used + as the mark for all the decision making and binding that happens during the match. + + + + + + + + Bind a value. + + + + + Bind a recursive set of values. + + + + + Applications combine type and term applications, and are normalized so + that sequential applications are combined, so "(f x y)" becomes "f [[x];[y]]". + The type attached to the function is the formal function type, used to ensure we don't build application + nodes that over-apply when instantiating at function types. + + + + + + + + Lambda expressions. + + + + + Sequence expressions, used for "a;b", "let a = e in b;a" and "a then b" (the last an OO constructor). + + + + + Reference a value. The flag is only relevant if the value is an object model member + and indicates base calls and special uses of object constructors. + + + + + A constant expression. + + + + + The big type of expressions. + + + + + + + + + + + + + + + + + + + + + + + The extra metadata stored about typars for top-level definitions. Any information here is propagated from signature through + to the compiled code. + + + + + + + + + + + The extra metadata stored about typars for top-level definitions. Any information here is propagated from signature through + to the compiled code. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + A target of a decision tree. Can be thought of as a little function, though is compiled as a local block. + + + + + Run the active pattern and bind a successful result to the (one) variable in the remaining tree + + + + + Test if the input to a decision tree is an instance of the given type + + + + + Test if the input to a decision tree is null + + + + + Test if the input to a decision tree is the given constant value + + + + + Test if the input to a decision tree is an array of the given length + + + + + Test if the input to a decision tree matches the given constructor + + + + + + + + + + + + + + Bind the given value throught the remaining cases of the dtree. + + + + + Indicates the decision tree has terminated with success, calling the given target with the given parameters + + + + + Indicates a decision point in a decision tree. + + + + + Decision trees. Pattern matching has been compiled down to + a decision tree by this point. The right-hand-sides (actions) of + the decision tree are labelled by integers that are unique for that + particular tree. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Constants in expressions + + + + + + + + AttribNamedArg(name,type,isField,value) + + + + + + + + We keep both source expression and evaluated expression around to help intellisense and signature printing + + + + + + + + Attrib(kind,unnamedArgs,propVal,appliedToAGetterOrSetter,range) + + + + + Indicates an attribute refers to a type defined in an imported F# assembly + + + + + Indicates an attribute refers to a type defined in an imported .NET assembly + + + + + + + + + + + + + + + + + + + + + + + + + + + + + The result of attempting to resolve an assembly name to a full ccu. + UnresolvedCcu will contain the name of the assembly that could not be resolved. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Ensure the ccu is derefable in advance. Supply a path to attach to any resulting error message. + + + + + + + + + + + A relinkable handle to the contents of a compilation unit. Relinking is performed by mutation. + + + + + + + + + + + + + + A helper function used to link method signatures using type equality. This is effectively a forward call to the type equality + logic in tastops.fs + + + + + A handle to the full specification of the contents of the module contained in this ccu + + + + + Indicates that this DLL uses quotation literals somewhere. This is used to implement a restriction on static linking + + + + + Indicates that this DLL was compiled using the F# compiler + + + + + A hint as to where does the code for the CCU live (e.g what was the tcConfig.implicitIncludeDir at compilation time for this DLL?) + + + + + The fully qualified assembly reference string to refer to this assembly. This is persisted in quotations + + + + + A unique stamp for this DLL + + + + + Holds the data indicating how this assembly/module is referenced from the code being compiled. + + + + + Holds the filename for the DLL, if any + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Indicates the type is a variable type, whether declared, generalized or an inference type parameter + + + + + Indicates the type is a non-F#-visible type representing a "proof" that a union value belongs to a particular union case + These types are not user-visible and will never appear as an inferred type. They are the types given to + the temporaries arising out of pattern matching on union values. + + + + + Indicates the type is a function type + + + + + Indicates the type is a tuple type + + + + + Indicates the type is a type application + + + + + Indicates the type is a universal type, only used for types of values, members and record fields + + + + + The algebra of types + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Indicates a reference to something bound in another CCU + + + + + Indicates a reference to something bound in this CCU + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + References are either local or nonlocal + + + + + + + + note: ModuleOrNamespaceRef and TyconRef are type equivalent + + + + + Indicates a reference to something bound in another CCU + + + + + Indicates a reference to something bound in this CCU + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Is the destination assembly available? + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Index into the namespace/module structure of a particular CCU + + + + + + + + + + + + + + The information ILXGEN needs about the location of an item + + + + + + + + + + + + + + + + + A public path records where a construct lives within the global namespace + of a CCU. + + + + + The name of the value, or the full signature of the member + + + + + A reference to the entity containing the value or member. THis will always be a non-local reference + + + + + + + + + + + + + + + + + + + + + + + Gets updated with 'true' if an abstract slot is implemented in the file being typechecked. Internal only. + + + + + Gets updated with full slotsig after interface implementation relation is checked + + + + + The parent type. For an extension member this is the type being extended + + + + + + + + XML documentation signature for the value + + + + + XML documentation attached to a value. + + + + + + + + Top level values have an arity inferred and/or specified + signatures. The arity records the number of arguments preferred + in each position for a curried functions. The currying is based + on the number of lambdas, and in each position the elements are + based on attempting to deconstruct the type of the argument as a + tuple-type. The field is mutable because arities for recursive + values are only inferred after the r.h.s. is analyzed, but the + value itself is created before the r.h.s. is analyzed. + + TLR also sets this for inner bindings that it wants to + represent as "top level" bindings. + + + + + Custom attributes attached to the value. These contain references to other values (i.e. constructors in types). Mutable to fixup + these value references after copying a colelction of values. + + + + + Is the value actually an instance method/property/event that augments + a type, and if so what name does it take in the IL? + + + + + How visible is this? + + + + + What is the original, unoptimized, closed-term definition, if any? + Used to implement [<ReflectedDefinition>] + + + + + + + + See vflags section further below for encoding/decodings here + + + + + + + + + + + + + + + + + + + + + + + + + + + + +Get the signature for the value's XML documentation + + + + +Get the signature for the value's XML documentation + + + + + Get the declared documentation for the value + + + + + Get the type of the value including any generic type parameters + + + + + The type of the value. + May be a Type_forall for a generic value. + May be a type variable or type containing type variables during type inference. + + + + + Get the generic type parameters for the value + + + + + + + + Get the actual parent entity for the value (a module or a type), i.e. the entity under which the + value will appear in compiled code. For extension members this is the module where the extension member + is declared. + + + + + Get the type of the value after removing any generic type parameters + + + + + A unique stamp within the context of this invocation of the compiler process + + + + + + + + Get the information about the value used during type inference + + + + + The place where the value was defined. + + + + + Get the public path to the value, if any? Should be set if and only if + IsMemberOrModuleBinding is set. + + + + + - If this is a property then this is 'Foo' + - If this is an implementation of an abstract slot then this is the name of the property implemented by the abstract slot + + + + + Does the value allow the use of an explicit type instantiation (i.e. does it itself have explciti type arguments, + or does it have a signature?) + + + + + Does the inline declaration for the value indicate that the value must be inlined? + + + + + Is this a member, if so some more data about the member. + + Note, the value may still be (a) an extension member or (b) and abtract slot without + a true body. These cases are often causes of bugs in the compiler. + + + + + Get the apparent parent entity for a member + + + + + Was the value inferred to be a method or function that definitely makes no critical tailcalls? + + + + + The name of the method. + - If this is a property then this is 'get_Foo' or 'set_Foo' + - If this is an implementation of an abstract slot then this is the name of the method implemented by the abstract slot + - If this is an extension member then this will be the simple name + + + + + The value of a value or member marked with [<LiteralAttribute>] + + + + + + + + + + + + + + Was this member declared 'override' or is it an implementation of an interface slot + + + + + Was the value declared 'mutable' + + + + + Is this a value in a module, or an extension member, but excluding compiler generated bindings from optimizations + + + + + Is this a member definition or module definition? + + + + + Is this a member, if so some more data about the member. + + Note, the value may still be (a) an extension member or (b) and abtract slot without + a true body. These cases are often causes of bugs in the compiler. + + + + + + + + Is this a member, excluding extension members + + + + + Is this an instance member. + + Note, the value may still be (a) an extension member or (b) and abtract slot without + a true body. These cases are often causes of bugs in the compiler. + + + + + Is this a member generated from the de-sugaring of 'let' function bindings in the implicit class syntax? + + + + + Is this a constructor member generated from the de-sugaring of implicit constructor for a class type? + + + + + + + + + + + Is this a 'new' constructor member + + + + + Was the value generated by the compiler? + + Note: this is true for the overrides generated by hash/compare augmentations + + + + + Is this something compiled into a module, i.e. a user-defined value, an extension member or a compiler-generated value + + + + + Is this represented as a "top level" static binding (i.e. a static field, static member, + instance member), rather than an "inner" binding that may result in a closure. + + This is implied by IsMemberOrModuleBinding, however not vice versa, for two reasons. + Some optimizations mutate this value when they decide to change the representation of a + binding to be IsCompiledAsTopLevel. Second, even immediately after type checking we expect + some non-module, non-member bindings to be marked IsCompiledAsTopLevel, e.g. 'y' in + 'let x = let y = 1 in y + y' (NOTE: check this, don't take it as gospel) + + + + + Was the value ever referenced? + + + + + Is this a compiler-generated class constructor member + + + + + Get the inline declaration on the value + + + + + + + + Was the value ever referenced? + + + + + - If this is a property then this is 'Foo' + - If this is an implementation of an abstract slot then this is the name of the method implemented by the abstract slot + - If this is an operator then this is '(+)' + + + + + Range of the definition (implementation) of the value, used by Visual Studio + Updated by mutation when the implementation is matched against the signature. + + + + + The name of the method. + - If this is a property then this is 'Foo' + - If this is an implementation of an abstract slot then this is the name of the method implemented by the abstract slot + - If this is an operator then this is 'op_Addition' + + + + + The name of the method in compiled code (with some exceptions where ilxgen.fs decides not to use a method impl) + - If this is a property then this is 'get_Foo' or 'set_Foo' + - If this is an implementation of an abstract slot then this may be a mangled name + - If this is an extension member then this will be a mangled name + - If this is an operator then this is 'op_Addition' + + + + + Is this a 'base' or 'this' value? + + + + + Get the declared attributes for the value + + + + + Get the apparent parent entity for the value, i.e. the entity under with which the + value is associated. For extension members this is the nominal type the member extends. + For other values it is just the actual parent. + + + + + The parent type or module, if any (None for expression bindings and parameters) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Indicates the signature of a member constraint. Contains a mutable solution cell + to store the inferred solution of the constraint. + + + + + + + + + + + + + + + + + The specification of a member constraint that must be solved + + + + + Indicates a constraint that a type is .NET unmanaged type + + + + + Indicates a constraint that a type is a delegate from the given tuple of args to the given return type + + + + + Indicates a constraint that a type does not have the Equality(false) attribute, or is not a structural type with this attribute, with special rules for some known structural container types + + + + + Indicates a constraint that a type implements IComparable, with special rules for some known structural container types + + + + + Indicates a constraint that a type is an enum with the given underlying + + + + + Indicates a constraint that a type has a parameterless constructor + + + + + Indicates a constraint that a type is a simple choice between one of the given ground types. See format.fs + + + + + Indicates a constraint that a type is a reference type + + + + + Indicates a constraint that a type is a non-Nullable value type + These are part of .NET's model of generic constraints, and in order to + generate verifiable code we must attach them to F# generalzied type variables as well. + + + + + Indicates a constraint that a type has a member with the given signature + + + + + Indicates a constraint that a type has a 'null' value + + + + + Indicates a default value for an inference type variable should it be netiher generalized nor solved + + + + + Indicates a constraint that a type is a subtype of the given type + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + The inferred constraints for the type inference variable + + + + + An inferred equivalence for a type inference variable. + + + + + The declared attributes of the type parameter. Empty for type inference variables. + + + + + The documentation for the type parameter. Empty for type inference variables. + + + + + The unique stamp of the typar blob. + + + + + + + + + + + + + + + + + Indicates the construct can only be accessed from any code in the given type constructor, module or assembly. [] indicates global scope. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Mutation used during compilation of FSharp.Core.dll + + + + + + + + + + + + + + + + + + + + + + + + + + Namespace or module-compiled-as-type? + + + + + + + + + + + + + + + + + + + + + + + Values, including members in F# types in this module-or-namespace-fragment. + + + + + + + + + + + Type, mapping mangled name to Tycon, e.g. + + + + + + + + + + + + + + + + + Mutation used during compilation of FSharp.Core.dll + + + + + + + + + + + + + + Indicates that a 'module' is really a namespace + + + + + Indicates that a module is compiled to a class with the same name as the original module + + + + + Indicates that a module is compiled to a class with the "Module" suffix added. + + + + + + + + Indicates that an exception is abstract, i.e. is in a signature file, and we do not know the representation + + + + + Indicates that an exception carries the given record of values + + + + + Indicates that an exception is shorthand for the given .NET exception type + + + + + Indicates that an exception is an abbreviation for the given exception + + + + + + + + Name/declaration-location of the field + + + + + Attributes attached to generated field + + + + + Attributes attached to generated property + + + + + Indicates the declared visibility of the field, not taking signatures into account + + + + + The default initialization info, for static literals + + + + + Indicates a compiler generated field, not visible to Intellisense or name resolution + + + + + Indicates a volatile field + + + + + Indicates a static field + + + + + The type of the field, w.r.t. the generic parameters of the enclosing type constructor + + + + + XML Documentation signature for the field + + + + + Documentation for the field + + + + + Is the field declared mutable in F#? + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + This may represent a "field" in either a struct, class, record or union + It is normally compiled to a property. + + + + + Attributes, attached to the generated static method to make instances of the case + + + + + Indicates the declared visibility of the union constructor, not taking signatures into account + + + + + Name/range of the case + + + + + XML documentation signature for the case + + + + + Documentation for the case + + + + + Name of the case in generated IL code + + + + + Return type constructed by the case. Normally exactly the type of the enclosing type, sometimes an abbreviation of it + + + + + Data carried by the case. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + The cases contained in the discriminated union. + + + + + The ILX data structure representing the discriminated union. + + + + + + + + The cases of the discriminated union, indexed by name. + + + + + The cases of the discriminated union, in declaration order. + + + + + + + + + + + + + + The fields of the record, indexed by name. + + + + + The fields of the record, in declaration order. + + + + + + + + + + + + + + + + + + + + + + + The fields of the class, struct or enum + + + + + The declared abstract slots of the class, interface or struct + + + + + Indicates whether the type declaration is a class, interface, enum, delegate or struct + + + + + + + + Indicates the type is an enumeration + + + + + Indicates the type is a delegate with the given Invoke signature + + + + + Indicates the type is a struct + + + + + Indicates the type is an interface + + + + + Indicates the type is a class (also used for units-of-measure) + + + + + + + + Indicates the type is parameterized on a measure (e.g. float<_>) but erases to some other type (e.g. float) + + + + + Indicates the type is implemented as IL assembly code using the given closed Abstract IL type + + + + + Indicates the type is a .NET type + + + + + Indicates the type is a discriminated union + + + + + Indicates the type is a record + + + + + Indicates the type is a class, struct, enum, delegate or interface + + + + + + + + Set to true if the type is determined to be abstract + + + + + Set to true at the end of the scope where proper augmentations are allowed + + + + + Super type, if any + + + + + Interface implementations - boolean indicates compiler-generated + + + + + Properties, methods etc. as lookup table + + + + + Properties, methods etc. in declaration order + + + + + True if the type defined an Object.GetHashCode method. In this + case we give a warning if we auto-generate a hash method since the semantics may not match up + + + + + This is the value implementing the auto-generated comparison + semantics if any. It is not present if the type defines its own implementation + of IStructuralEquatable or if the type doesn't implement IComparable implicitly. + + + + + This is the value implementing the auto-generated equality + semantics if any. It is not present if the type defines its own implementation + of Object.Equals or if the type doesn't override Object.Equals implicitly. + + + + + This is the value implementing the auto-generated comparison + semantics if any. It is not present if the type defines its own implementation + of IStructuralComparable or if the type doesn't implement IComparable implicitly. + + + + + This is the value implementing the auto-generated comparison + semantics if any. It is not present if the type defines its own implementation + of IComparable or if the type doesn't implement IComparable implicitly. + + + + + + + + + + + + + + + + + Used during codegen to hold the ILX representation indicating how to access the type + + + + + The stable path to the type, e.g. Microsoft.FSharp.Core.FSharpFunc`2 + + + + + + + + The stable path to the type, e.g. Microsoft.FSharp.Core.FSharpFunc`2 + + + + + The XML document signature for this entity + + + + + The declared documentation for the type or module + + + + + This field is used when the 'tycon' is really a module definition. It holds statically nested type definitions and nested modules + + + + + Field used when the 'tycon' is really an exception definition + + + + + The methods and properties of the type + + + + + If non-None, indicates the type is an abbreviation for another type. + + + + + The declared representation of the type, i.e. record, union, class etc. + + + + + The declared attributes for the type + + + + + The declared accessibility of the representation, not taking signatures into account + + + + + The declaration location for the type constructor + + + + + The name of the type, possibly with `n mangling + + + + + The name of the type, possibly with `n mangling + + + + + The unique stamp of the "tycon blob". Note the same tycon in signature and implementation get different stamps + + + + + + + + + + + The declared type parameters of the type + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Note: result is alphabetically sorted, then for each name the results are in declaration order + + + + + Note: result is a indexed table, and for each name the results are in reverse declaration order + + + + + + + + + + + + + + + + + + + + Indicates the type prefers the "tycon<a,b>" syntax for display etc. + + + + + + + + Indicates the "tycon blob" is actually a module + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + From TAST TyconRef to IL ILTypeRef + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Get the flags as included in the F# binary metadata + + + + + + + + + + + + + + + + + + + + Encode entity flags into a bit field. We leave lots of space to allow for future expansion. + + + + + + + + + + + + + + Get the flags as included in the F# binary metadata. We pickle this as int64 to allow for future expansion + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Encode typar flags into a bit field + + + + + Indicates the type parameter derives from an '_' anonymous type + For units-of-measure, we give a warning if this gets solved to '1' + + + + + Indicates the type parameter is an inference variable may be solved + + + + + Indicates we give a warning if the type parameter is ever solved + + + + + Indicates the type parameter can't be solved, but the variable is not set to "rigid" until after inference is complete + + + + + Indicates the type parameter can't be solved + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Get the flags as included in the F# binary metadata + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Indicates the 'this' value specified in a memberm e.g. 'x' in 'member x.M() = 1' + + + + + Indicates a normal value + + + + + Indicates the value called 'base' available for calling base class members + + + + + Indicates a ref-cell holding 'this' or the implicit 'this' used throughout an + implicit constructor to access and set values + + + + + + + + Indicates the type parameter is needed at runtime and may not be eliminated + + + + + Indicates the type parameter is not needed at runtime and may be eliminated + + + + + + + + + + + + + + + + + The normal value for this flag when the value is not within its recursive scope + + + + + Set while the value is within its recursive scope. The flag indicates if the value has been eagerly generalized and accepts generic-recursive calls + + + + + + + + + + + + + + Indictes the value is inlined but the code for the function still exists, e.g. to satisfy interfaces on objects, but that it is also always inlined + + + + + Indicates the value must always be inlined + + + + + + + + + + + + + + Unique name generator for stamps attached to lambdas and object expressions + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Primitive routine to compare two EntityRef's for equality + This takes into account the possibility that they may have type forwarders + + + + + This predicate tests if non-local resolution paths are definitely known to resolve + to different entities. All references with different named paths always resolve to + different entities. Two references with the same named paths may resolve to the same + entities even if they reference through different CCUs, because one reference + may be forwarded to another via a .NET TypeForwarder. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Equality on CCU references, implemented as reference equality except when unresolved + + + + + + + + + + + + + + + + + + + + + + + Unique name generator for stamps attached to to val_specs, tycon_specs etc. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Metadata on values (names of arguments etc. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.PowerPack.Parallel.Seq.dll b/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.PowerPack.Parallel.Seq.dll new file mode 100644 index 0000000000000000000000000000000000000000..b830f584380ce91790a9284d11814ea21fef6d98 Binary files /dev/null and b/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.PowerPack.Parallel.Seq.dll differ diff --git a/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.PowerPack.Parallel.Seq.xml b/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.PowerPack.Parallel.Seq.xml new file mode 100644 index 0000000000000000000000000000000000000000..d60554eed4dec77300414fd461adf8ad513a92a3 --- /dev/null +++ b/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.PowerPack.Parallel.Seq.xml @@ -0,0 +1,817 @@ + + +FSharp.PowerPack.Parallel.Seq + + + + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + Operates in parallel, using System.Linq.Parallel. 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. + Operates in parallel, using System.Linq.Parallel. 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. + Operates in parallel, using System.Linq.Parallel. 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. + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + Operates in parallel, using System.Linq.Parallel. 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. + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + Operates in parallel, using System.Linq.Parallel. 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. + Operates in parallel, using System.Linq.Parallel. 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. + Operates in parallel, using System.Linq.Parallel. 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. + Operates in parallel, using System.Linq.Parallel. 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. + Operates in parallel, using System.Linq.Parallel. 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. + + + + + + + + + + + + + + + + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. Builds a list from the given collection. + + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + + + Operates in parallel, using System.Linq.Parallel. Builds an array from the given collection. + + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. Returns a sequence that yields one item only. + + The input item. + + The result sequence. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. Views the given list as a sequence. + + The input list. + + The result sequence. + + + Operates in parallel, using System.Linq.Parallel. Views the given array as a sequence. + + The input array. + + The result sequence. + + Thrown when the input sequence is null. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. Returns the lengthof the sequence + + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. Returns true if the sequence contains no elements, false otherwise. + + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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 + + + Operates in parallel, using System.Linq.Parallel. 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 + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. Creates an empty sequence. + + The result sequence. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Operates in parallel, using System.Linq.Parallel. 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. + + + Parallel operations on IEnumerables. + + + diff --git a/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.PowerPack.dll b/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.PowerPack.dll new file mode 100644 index 0000000000000000000000000000000000000000..0e4b2eb7940ad53fd00f446b7b392b9430189cb4 Binary files /dev/null and b/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.PowerPack.dll differ diff --git a/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.PowerPack.targets b/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.PowerPack.targets new file mode 100644 index 0000000000000000000000000000000000000000..d07d00757364b53eb2802c04c0ba624be79bd891 --- /dev/null +++ b/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.PowerPack.targets @@ -0,0 +1,84 @@ + + + + + + + CallFsLex;CallFsYacc;$(CompileDependsOn) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + false + + + false + + + + + diff --git a/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.PowerPack.xml b/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.PowerPack.xml new file mode 100644 index 0000000000000000000000000000000000000000..0293bac7a5062e7ae5c0117482d4c977cd8eb480 --- /dev/null +++ b/packages/FSPowerPack.Community.2.0.0.0/Tools/FSharp.PowerPack.xml @@ -0,0 +1,5118 @@ + + +FSharp.PowerPack + + + + Lookup or set the given element in the table. Set replaces all existing bindings for a value with a single + bindings. Raise <c>KeyNotFoundException</c> if the element is not found. + + + + + Lookup or set the given element in the table. Set replaces all existing bindings for a value with a single + bindings. Raise <c>KeyNotFoundException</c> if the element is not found. + + + + + The total number of keys in the hash table + + + + + Lookup the given element in the table, returning the result as an Option + + + + + Replace the latest binding (if any) for the given element. + + + + + Remove the latest binding (if any) for the given element from the table + + + + +Apply the given function to each binding in the hash table + + + + + Apply the given function to each element in the collection threading the accumulating parameter + through the sequence of function applications + + + + + Find all bindings for the given element in the table, if any + + + + + + + + + + + + + + Make a shallow copy of the collection + + + + + Test if the collection contains any bindings for the given element + + + + + Clear all elements from the collection + + + + + Add a binding for the element to the table + + + + + + + + + + + + + + Build a map that contains the bindings of the given IEnumerable + + + + + Create a new empty mutable HashMultiMap with an internal bucket array of the given approximate size + and with the given key hash/equality functions + + + + + Create a new empty mutable HashMultiMap with the given key hash/equality functions + + + + + Hash tables, by default based on F# structural "hash" and (=) functions. + The table may map a single key to multiple bindings. + + + + + The total number of elements in the set + + + + + Remove the given element from the set + + + + + Apply the given function to each binding in the hash table + + + + + Apply the given function to the set threading the accumulating parameter + through the sequence of function applications + + + + + Make a shallow copy of the set + + + + + Test if the set contains the given element + + + + + Clear all elements from the set + + + + + Add an element to the collection + + + + + + + + + + + + + + Create a new mutable hash set with the given elements and using the given key hash/equality functions + + + + + Create a new empty mutable hash set with an internal bucket array of the given approximate size + and with the given key hash/equality functions + + + + + Create a new empty mutable hash set using the given key hash/equality functions + + + + + Mutable hash sets based by default on F# structural "hash" and (=) functions. Implemented via a hash table and/or Dictionary. + + + + + LazyLists are possibly-infinite, cached sequences. See also IEnumerable/Seq for + uncached sequences. LazyLists normally involve delayed computations without + side-effects. The results of these computations are cached and evaluations will be + performed only once for each element of the lazy list. In contrast, for sequences + (IEnumerable) recomputation happens each time an enumerator is created and the sequence + traversed. + + LazyLists can represent cached, potentially-infinite computations. Because they are + cached they may cause memory leaks if some active code or data structure maintains a + live reference to the head of an infinite or very large lazy list while iterating it, + or if a reference is maintained after the list is no longer required. + + Lazy lists may be matched using the LazyList.Cons and LazyList.Nil active patterns. + These may force the computation of elements of the list. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Build a new collection from the given enumerable object + + + + + Return a view of the collection as an enumerable object + + + + + Build a non-lazy list from the given collection. This function will eagerly evaluate all of the + list (and thus may not terminate). + + + + + Build a collection from the given list. This function will eagerly evaluate all of the + list (and thus may not terminate). + + + + + Build an array from the given collection + + + + + Build a collection from the given array. This function will eagerly evaluate all of the + list (and thus may not terminate). + + + + + Build a new collection whose elements are the results of applying the given function + to the corresponding elements of the two collections pairwise. + + + + + Build a new collection whose elements are the results of applying the given function + to each of the elements of the collection. + + + + + Return a new list consisting of the results of applying the given accumulating function + to successive elements of the list + + + + + Apply the given function to each element of the collection. + + + + + Return a new collection which on consumption will consist of only the elements of the collection + for which the given predicate returns "true" + + + + + Return the list which contains on demand the list of elements of the list of lazy lists. + + + + + Return the list which contains on demand the pair of elements of the first and second list + + + + + Return the list which contains on demand the elements of the first list followed + by the elements of the second list + + + + + Return a list that contains the elements returned by the given computation. + The given computation is not executed until the first element on the list is + consumed. The given argument is passed to the computation. Subsequent elements + in the list are generated by again applying the residual 'b to the computation. + + + + + Return a list that is in effect the list returned by the given computation. + The given computation is not executed until the first element on the list is + consumed. + + + + + Return the list which on consumption will consist of an infinite sequence of + the given item + + + + + Return a new list which on consumption contains the given item + followed by the list returned by the given computation. The + + + + + Return a new list which contains the given item followed by the + given list. + + + + + Return the length of the list + + + + + Evaluates to the list that contains no items + + + + + Return the first element for which the given function returns <c>true</c>. + Raise <c>KeyNotFoundException</c> if no such element exists. + + + + + Apply the given function to successive elements of the list, returning the first + result where function returns <c>Some(x)</c> for some x. If the function never returns + true, 'None' is returned. + + + + + Return the list which on consumption will skip the first 'n' elements of + the input list. + + + + + Return the list which on consumption will consist of at most 'n' elements of + the input list. + + + + + Get the first cell of the list. + + + + + Return the list corresponding to the remaining items in the sequence. + Forces the evaluation of the first cell of the list if it is not already evaluated. + + + + + Return the first element of the list. Forces the evaluation of + the first cell of the list if it is not already evaluated. + + + + + Test if a list is empty. Forces the evaluation of + the first element of the stream if it is not already evaluated. + + + + + + + + Split an array of pairs into two arrays + + + + + Combine the two arrays into an array of pairs. The two arrays must have equal lengths, otherwise an <c>ArgumentException</c> is + raised.. + + + + + Return the index of the first element in the array + that satisfies the given predicate. + + + + + Return the index of the first element in the array + that satisfies the given predicate. + + + + + Return an array containing the given element + + + + + Like <c>foldBack</c>, but return both the intermediary and final results + + + + + Like <c>fold</c>, but return the intermediary and final results + + + + + Build 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 <c>ArgumentException</c> is + raised. + + + + + Apply 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 <c>ArgumentException</c> is raised. + + + + + Return true if the given array is empty, otherwise false + + + + + Test elements of the two arrays pairwise to see if all pairs of elements satisfy the given predicate. + Raise ArgumentException if the arrays have different lengths. + + + + + 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 <c>ArgumentException</c> is + raised. + + + + + Apply 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 <c>ArgumentException</c> is + raised. + + + + + Apply a function to each element of the array, threading an accumulator argument + through the computation. If the input function is <c>f</c> and the elements are <c>i0...iN</c> then + computes <c>f i0 (...(f iN-1 iN))</c>. Raises ArgumentException if the array has size zero. + + + + + Apply a function to each element of the array, threading an accumulator argument + through the computation. If the input function is <c>f</c> and the elements are <c>i0...iN</c> + then computes <c>f (... (f i0 i1)...) iN</c>. Raises ArgumentException if the array has size zero. + + + + + Return the index of the first element in the array + that satisfies the given predicate. Raise <c>KeyNotFoundException</c> if + none of the elements satisfy the predicate. + + + + + Return the index of the first element in the array + that satisfies the given predicate. Raise <c>KeyNotFoundException</c> if + none of the elements satisfy the predicate. + + + + + Test elements of the two arrays pairwise to see if any pair of element satisfies the given predicate. + Raise ArgumentException if the arrays have different lengths. + + + + + + + + Return a view of the array as an enumerable object + + + + + Build a ResizeArray from the given elements + + + + + Return a fixed-length array containing the elements of the input ResizeArray + + + + + Sort the elements using the key extractor and generic comparison on the keys + + + + + Sort the elements using the given comparison function + + + + +Return a new array with the elements in reverse order + + + + +Split a list of pairs into two lists + + + + +Combine the two arrays into an array of pairs. The two arrays must have equal lengths. + + + + +Apply the given function to successive elements, returning the first +result where function returns "Some(x)" for some x. + + + + +Return the first element for which the given function returns <c>true</c>. +Return None if no such element exists. + + + + +Return the first element for which the given function returns <c>true</c>. +Raise <c>KeyNotFoundException</c> if no such element exists. + + + + +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) + + + + +Split the collection into two collections, containing the +elements for which the given predicate returns <c>true</c> and <c>false</c> +respectively + + + + +Return a new collection containing only the elements of the collection +for which the given predicate returns <c>true</c> + + + + + Test if all elements of the array satisfy the given predicate. + If the input function is <c>f</c> and the elements are <c>i0...iN</c> and "j0...jN" + then computes <c>p i0 && ... && p iN</c>. + + + + + Test if any element of the array satisfies the given predicate. + If the input function is <c>f</c> and the elements are <c>i0...iN</c> + then computes <c>p i0 or ... or p iN</c>. + + + + +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. + + + + +Apply the given function to each element of the array. The integer passed to the +function indicates the index of element. + + + + +Build 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. + + + + +Apply the given function to two arrays simultaneously. The +two arrays must have the same lengths, otherwise an Invalid_argument exception is +raised. + + + + +Build a new array whose elements are the results of applying the given function +to each of the elements of the array. + + + + +Apply the given function to each element of the array. + + + + + Apply a function to each element of the array, threading an accumulator argument + through the computation. If the input function is <c>f</c> and the elements are <c>i0...iN</c> then + computes <c>f i0 (...(f iN s))</c>. + + + + + Apply a function to each element of the collection, threading an accumulator argument + through the computation. If the input function is <c>f</c> and the elements are <c>i0...iN</c> + then computes <c>f (... (f s i0)...) iN</c> + + + + +Build and array from the given seq + + + + + + + +Build an array from the given list + + + + + + + +Build a list from the given array + + + + +Read a range of elements from the first array and write them into the second. + + + + +Fill a range of the collection with the given element + + + + +Build a new array that contains the elements of the given array + + + + +Build a new array that contains the given subrange specified by +starting index and length. + + + + +Build a new array that contains the elements of each of the given list of arrays + + + + +Build a new array that contains the elements of the first array followed by the elements of the second array + + + + + Create an array by calling the given generator on each index. + + + + + Create an array whose elements are all initially the given value. + + + + + Set the value of an element in the collection. You can also use the syntax <c>arr.[idx] <- e</c>. + + + + + Fetch an element from the collection. You can also use the syntax <c>arr.[idx]</c>. + + + + + Return the length of the collection. You can also use property <c>arr.Length</c>. + + + + + Generic operations on the type System.Collections.Generic.List, which is called ResizeArray in the F# libraries. + + + + + + + + Lookup or set the given element in the table. Raise <c>KeyNotFoundException</c> if the element is not found. + + + + + Lookup or set the given element in the table. Raise <c>KeyNotFoundException</c> if the element is not found. + + + + + The number of bindings in the hash table + + + + + Lookup the given element in the table, returning the result as an Option + + + + + Replace the latest binding (if any) for the given element. + + + + + Remove the latest binding (if any) for the given element from the table + + + + + Apply the given function to each binding in the hash table + + + + + Apply the given function to each element in the collection threading the accumulating parameter + through the sequence of function applications + + + + + Find all bindings for the given element in the table, if any + + + + + Create a new empty mutable hash table with an internal bucket array of the given approximate size + and with the given key hash/equality functions + + + + + Make a shallow copy of the collection + + + + + Test if the collection contains any bindings for the given element + + + + + Test if the collection contains any bindings for the given element + + + + + Clear all elements from the collection + + + + + Add a binding for the element to the table + + + + + HashMultiMap, but where a constraint tag tracks information about the hash/equality functions used + for the hashing. When the tag is Tags.StructuralHash this is identical to HashMultiMap. + + + + + + + + The number of elements in the set + + + + + Remove the given element from the set + + + + + Apply the given function to each binding in the hash table + + + + + Apply the given function to the set threading the accumulating parameter + through the sequence of function applications + + + + + Create a new empty mutable hash set with an internal bucket array of the given approximate size + and with the given key hash/equality functions + + + + + Make a shallow copy of the set + + + + + Test if the set contains the given element + + + + + Clear all elements from the set + + + + + Add an element to the collection + + + + + Mutable hash sets where a constraint tag tracks information about the hash/equality functions used + for the hashing. When the tag is Tags.StructuralHash this is identical to HashSet. + + + + + + + + Lookup an element in the map. Raise <c>KeyNotFoundException</c> if no binding + exists in the map. + + + + + Gets a value indicating whether there are no bindings in the map. + + + + + The number of bindings in the map + + + + + Gets the comparer used for the map. + + + + + Lookup an element in the map, returning a <c>Some</c> value if the element is in the domain + of the map and <c>None</c> if not. + + + + + The elements of the set as a list. + + + + + The elements of the set as an array + + + + + Remove an element from the domain of the map. No exception is raised if the element is not present. + + + + + Build two new maps, one containing the bindings for which the given predicate returns 'true', + and the other the remaining bindings. + + + + + Build a new collection whose elements are the results of applying the given function + to each of the elements of the collection. + + + + + Build a new collection whose elements are the results of applying the given function + to each of the elements of the collection. The index passed to the + function indicates the index of element being transformed. + + + + + Apply the given function to each binding in the dictionary + + + + + + + + Return true if the given predicate returns true for all of the + bindings in the map. Always returns true if the map is empty. + + + + + Given the start and end points of a key range, + Fold over the bindings in the map that are in the range, + and the end points are included if present (the range is considered a closed interval). + + + + + Fold over the bindings in the map. + + + + + Fold over the bindings in the map. + + + + + Search the map looking for the first element where the given function returns a <c>Some</c> value + + + + + Build a new map containing the bindings for which the given predicate returns 'true'. + + + + + Return true if the given predicate returns true for one of the + bindings in the map. Always returns false if the map is empty. + + + + + + + + The empty map, and use the given comparer comparison function for all operations associated + with any maps built from this map. + + + + + Build a map that contains the bindings of the given IEnumerable + and where comparison of elements is based on the given comparison function + + + + + Test is an element is in the domain of the map + + + + + Return a new map with the binding added to the given map. + + + + + Immutable maps. Keys are ordered by construction function specified + when creating empty maps or by F# structural comparison if no + construction function is specified. + + <performance> + Maps based on structural comparison are + efficient for small keys. They are not a suitable choice if keys are recursive data structures + or require non-structural comparison semantics. + </performance> + Immutable maps. A constraint tag carries information about the class of key-comparers being used. + + + + + + + + Return a new set with the elements of the second set removed from the first. + + + + + Compute the union of the two 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. + + + + + Return the number of elements in the set + + + + + Gets the comparer used for the set. + + + + + The number of elements in the set + + + + + Compute the union of the two sets. + + + + + The elements of the set as a list. + + + + + The elements of the set as an array. + + + + + A singleton set based on the given comparison operator + + + + + 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. + + + + + Build two new sets, one containing the elements for which the given predicate returns 'true', + and the other the remaining elements. + + + + + Apply the given function to each binding in the collection + + + + + Evaluates to "true" if all elements of the first set are in the second + + + + + Evaluates to "true" if all elements of the second set are in the first + + + + + Compute the intersection of the two sets. + + + + + Test if all elements of the collection satisfy the given predicate. + If the input function is <c>f</c> and the elements are <c>i0...iN</c> and <c>j0...jN</c> then + computes <c>p i0 && ... && p iN</c>. + + + + + Apply the given accumulating function to all the elements of the set + + + + + Return a new collection containing only the elements of the collection + for which the given predicate returns "true" + + + + + Test if any element of the collection satisfies the given predicate. + If the input function is <c>f</c> and the elements are <c>i0...iN</c> then computes + <c>p i0 or ... or p iN</c>. + + + + + + + + Compares two sets and returns true if they are equal or false otherwise + + + + + The empty set based on the given comparer + + + + + Return a new set with the elements of the second set removed from the first. + + + + + A set based on the given comparer containing the given initial elements + + + + + A useful shortcut for Set.contains. See the Set module for further operations on sets. + + + + + Compares a and b and returns 1 if a > b, -1 if b < a and 0 if a = b + + + + + A useful shortcut for Set.add. Note this operation prodcues 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. + + + + + Immutable sets based on binary trees, default tag + Immutable sets where a constraint tag carries information about the class of key-comparer being used. + + + + + Wait for the result and commit it + + + + + Record the result in the AsyncResultCell. Subsequent sets of the result are ignored. + + This may result in the scheduled resumption of a waiting asynchronous operation + + + + + Create a new result cell + + + + + A helper type to store a single result from an asynchronous computation and asynchronously + access its result. + + + + + + + + + + + + + + Create an async whose result depends on the value of an AsyncResult. + + + + + Represents the reified result of an asynchronous computation + + + + + An async that produces true if the reader is at the end of stream and false otherwise + + Note that when the async is run it reflects the reader state at the time of running; multiple runs will + yield different results. + + + + + + + + + + + Creates an async that read all characters in the stream up to the end. + + Note that when the async is run it reflects the reader state at the time of running; multiple runs will + yield different results. + + + + + Creates an async that reads next line from the stream + + Note that when the async is run it reflects the reader state at the time of running; multiple runs will + yield different results. + + + + + Creates an async that reads exactly <c>count</c> characters from the stream unless end of stream is reached and puts them + into <c>buffer</c> starting at <c>index</c>. The async returns the number of characters that are read (if end-of-stream is not reached + that will be <c>count</c> + + Note that when the async is run it reflects the reader state at the time of running; multiple runs will + yield different results. + + + + + Creates an async that reads all the charactes that are avilable in the stream up to <c>count</c characters and puts them + into <c>buffer</c> starting at <c>index</c>. The async returns the number of characters that are read. + + Note that when the async is run it reflects the reader state at the time of running; multiple runs will + yield different results. + + + + + Creates an async that reads next character from the stream + + Note that when the async is run it reflects the reader state at the time of running; multiple runs will + yield different results. + + + + + Creates an async that produces next character from the stream without advancing the stream + + Note that when the async is run it reflects the reader state at the time of running; multiple runs will + yield different results. + + + + +. DiscardBufferedData tells StreamReader to throw away its internal +. buffer contents. This is useful if the user needs to seek on the + underlying stream to a known location then wants the StreamReader + to start reading from this new point. This method should be called + very sparingly, if ever, since it can lead to very poor performance. + However, it may be the only way of handling some scenarios where + users need to re-read the contents of a StreamReader a second time. + + + + + + + + + + + + + + + + + + + + Creates a new AsyncStreamReader for the given stream. The + character encoding is set by encoding and the buffer size, + in number of 16-bit characters, is set by bufferSize. + + Note that detectEncodingFromByteOrderMarks is a very + loose attempt at detecting the encoding by looking at the first + 3 bytes of the stream. It will recognize UTF-8, little endian + unicode, and big endian unicode text, but that's it. If neither + of those three match, it will use the Encoding you provided. + + + + + Implements a TextReader-like API that asynchronously reads characters from + a byte stream in a particular encoding. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + See Lazy.Force + + + + + + + + + + + Return the given rational number + + + + + Return the negation of a rational number + + + + + Return the difference of two rational numbers + + + + + Return the product of two rational numbers + + + + + This operator is for use from other .NET languages + + + + + This operator is for use from other .NET languages + + + + + This operator is for use from other .NET languages + + + + + This operator is for use from other .NET languages + + + + + This operator is for use from other .NET languages + + + + + Return the result of converting the given rational number to an integer + + + + + Return the result of converting the given rational number to a big integer + + + + + Return the result of converting the given rational number to a floating point number + + + + + This operator is for use from other .NET languages + + + + + Return the ratio of two rational numbers + + + + + Return the sum of two rational numbers + + + + + Get zero as a rational number + + + + + + + + Return the sign of a rational number; 0, +1 or -1 + + + + + Get one as a rational number + + + + + Return the numerator of the normalized rational number + + + + + Return a boolean indicating if this rational number is strictly positive + + + + + Return a boolean indicating if this rational number is strictly negative + + + + + Return the denominator of the normalized rational number + + + + + + + + Return the result of converting the given rational number to an integer + + + + + Return the result of converting the given rational number to a floating point number + + + + + Return the result of converting the given rational number to a big integer + + + + + Return the result of raising the given rational number to the given power + + + + + Return the result of converting the string to a rational number + + + + + + + + Return the result of converting the given integer to a rational number + + + + + Return the result of converting the given big integer to a rational number + + + + + Return the absolute value of a rational number + + + + + The type of arbitrary-sized rational numbers + + + + + Unary negation of a complex number + + + + + Subtract one complex number from another + + + + + Multiply a complex number by a scalar + + + + + Multiply a scalar by a complex number + + + + + Multiply two complex numbers + + + + + Complex division of two complex numbers + + + + + Add two complex numbers + + + + + The real part of a complex number + + + + + The imaginary part of a complex number + + + + + The complex number 0+0i + + + + + The real part of a complex number + + + + + The polar-coordinate phase of a complex number + + + + + The complex number 0+1i + + + + + The complex number 1+0i + + + + + The polar-coordinate magnitude of a complex number + + + + + The imaginary part of a complex number + + + + + The conjugate of a complex number, i.e. x-yi + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Create a complex number using magnitude/phase polar coordinates + + + + + Create a complex number x+ij using rectangular coordinates + + + + + + + + Computes the absolute value of a complex number: e.g. Abs x+iy = sqrt(x**2.0 + y**2.0.) + Note: Complex.Abs(z) is the same as z.Magnitude + + + + + The type of complex numbers stored as pairs of 64-bit floating point numbers in rectangular coordinates + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Get the item at the given position in a matrix + + + + + Prefix '+' operator. A nop. + + + + + Matrix negation. + + + + + Point-wise subtraction of two matrices. An InvalidArgument exception will be + raised if the dimensions do not match. + + + + + Multiply each element of a matrix by a scalar value + + + + + Multiply each element of a matrix by the given scalar value + + + + + Matrix-vector multiplication. + + + + + Matrix multiplication. An InvalidArgument exception will be + raised if the dimensions do not match. + + + + + Point-wise matrix multiplication. An InvalidArgument exception will be + raised if the dimensions do not match. + + + + + Point-wise addition of two matrices. An InvalidArgument exception will be + raised if the dimensions do not match. + + + + + Get the transpose of a matrix. + + + + + + + + Get the number of rows in a matrix + + + + + Get the number of columns in a matrix + + + + + Returns sqrt(sum(norm(x)*(norm(x))) of all the elements of a matrix. + The element type of a matrix must have an associated instance of INormFloat<'T> (see <c>GlobalAssociations</c>) ((else NotSupportedException)). + + + + + Return the non-zero entries of a sparse or dense matrix + + + + + Get the item at the given position in a matrix + + + + + Indicates if a matrix uses the sparse representation. + + + + + Indicates if a matrix uses the dense representation. + + + + + Get the internal array of values for a sparse matrix. This property + should only be used when interoperating with other matrix libraries. + + + + + Get the internal array of row offsets for a sparse matrix. This property + should only be used when interoperating with other matrix libraries. + + + + + Get the internal array of column values for a sparse matrix. This property + should only be used when interoperating with other matrix libraries. + + + + + Get the internal array of values for a dense matrix. This property + should only be used when interoperating with other matrix libraries. + + + + + Retrieve the dictionary of numeric operations associated with the element + type of this matrix. Accessing the property may raise an NotSupportedException if the element + type doesn't support any numeric operations. The object returned + may support additional numeric operations such as IFractional: + this can be determined by a dynamic type test against the object + returned. + + + + + Get the number of (rows,columns) in a matrix + + + + + Get the main diagonal of a matrix, as a vector + + + + + Convert a matrix to a column vector + + + + + Convert a matrix to a row vector + + + + + Return a new array containing the elements of a matrix + + + + + + + + Supports the slicing syntax 'A.[idx1..idx2,idx1..idx2] <- B' + + + + + Select a range of rows from a matrix + + + + + Select a row from a matrix + + + + + Select a region from a matrix + + + + + Permutes the rows of a matrix. + + + + + Permutes the columns of a matrix. + + + + + Supports the slicing syntax 'A.[idx1..idx2,idx1..idx2]' + + + + + + + + Return the nth diagonal of a matrix, as a vector. Diagonal 0 is the primary + diagonal, positive diagonals are further to the upper-right of a matrix. + + + + + + + + Create a new matrix that is a copy of an array + + + + + Select a range of columns from a matrix + + + + + Select a column from a matrix + + + + + The type of matrices. The arithmetic operations on the element type are determined by inspection on the element type itself. + Two representations are supported: sparse and dense. + + + + + A permutation of a finite range of integers 0 .. N-1, represented by a mapping of index positions + + + + + + + + Return a row vector, unchanged + + + + + Point-wise negation of a row vector + + + + + Point-wise subtraction of two row vectors + + + + + Multiply a scalar by a row vector + + + + + Multiply a row vector by a scalar + + + + + Multiply a row vector by a matrix + + + + + Multiply a row vector by a vector + + + + + Point-wise multiplication of two row vectors + + + + + Point-wise addition of two row vectors + + + + + Get the transpose of the row vector. + + + + + + + + + + + + + + + + + Get the underlying internal array of values for a vector. This property + should only be used when interoperating with other matrix libraries. + + + + + + + + Return a new array containing a copy of the elements of a vector + + + + + Supports the slicing syntax 'rv.[idx1..idx2] <- rv2' + + + + + Permute the elements of the row vector. + + + + + Supports the slicing syntax 'rv.[idx1..idx2]' + + + + + + + + + + + Create a new matrix that is a copy of a array + + + + + The type of row vectors. + + + + + Gets an item from a vector + + + + + Return the input vector + + + + + Negate a vector + + + + + Subtract two vectors, pointwise + + + + + Multiply a vector by a scalar + + + + + Multiply a column vector and a row vector to produce a matrix + + + + + Multiply each element of a vector by a scalar value. + + + + + Point-wise multiplication of two vectors. + + + + + Add two vectors, pointwise + + + + + Get the transpose of a vector. + + + + + + + + Gets the number of rows in a vector + + + + + Computes the 2-norm of a vector: sqrt(x.Transpose*x). + + + + + Gets the number of entries in a vector + + + + + Gets an item from a vector + + + + + Get the underlying internal array of values for a vector. This property + should only be used when interoperating with other matrix libraries. + + + + + Gets the element operations for the element type of a vector, if any + + + + + Return a new array containing a copy of the elements of a vector + + + + + Supports the slicing syntax 'v.[idx1..idx2] <- v2' + + + + + Permute the elements of a vector. + + + + + Supports the slicing syntax 'v.[idx1..idx2]' + + + + + + + + + + + Create a new matrix that is a copy of a array + + + + + The type of column vectors. The arithmetic operations on the element type are determined by inspection + on the element type itself + + + + + + + + The type of complex numbers + + + + + The type of floating point matrices + + + + + + + + The type of floating point row vectors + + + + + The type of floating point column vectors + + + + + Tagent + + + + + Cosine + + + + + Sine + + + + + sqrt(x) and 0 <= phase(x) < pi + + + + + log(x) is natural log (base e) + + + + + exp(x) = e^x + + + + + pi + + + + + Multiply a complex number by a scalar + + + + + Multiply a scalar by a complex number + + + + + Unary negation of a complex number + + + + + Complex division of two complex numbers + + + + + Multiply two complex numbers + + + + + Subtract one complex number from another + + + + + Add two complex numbers + + + + + The complex number 0+1i + + + + + The complex number 1+0i + + + + + The complex number 0+0i + + + + + The conjugate of a complex number, i.e. x-yi + + + + + A complex of magnitude 1 and the given phase and , i.e. cis x = mkPolar 1.0 x + + + + + Create a complex number using magnitude/phase polar coordinates + + + + + The imaginary part of a complex number + + + + + The real part of a complex number + + + + + The polar-coordinate phase of a complex number + + + + + The polar-coordinate magnitude of a complex number + + + + + + + + + + + Constructs a complex number from both the real and imaginary part. + + + + + + + + Record an AppDomain-wide association between the given type and the given dictionary of + numeric operations. Raise an error if an existing association already exists. + + + + + + + + Attempt to determine a numeric association for the given type, i.e. a registered dictionary of + numeric operations. The interface can be queried dynamically for additional functionality in the numerics + hierarchy. + + + + + Associations are a way of associating dictionaries of + operations with given types at runtime. Associations are global to a + .NET application domain. Once specified an association may not be deleted + or modified. + + In this release the system of associations is simply + limited to a registry of types that support dictionaries (i.e. interface objects) + of numeric operations. The following types are pre-registered with associated numeric + operations: float, int32, int64, bigint, float32, Complex, bignum. Other types must be + registered explicitly by user code. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + In-place subtraction, mutating the first matrix argument. + + + + + In-place addition, mutating the first matrix argument. + + + + + Create a new matrix that is a copy of the given array + + + + + Map the given indexed function over each element of a matrix, producing a new matrix + + + + + Map a function over each element of a matrix, producing a new matrix + + + + + Fold a function down a particular row of a matrix + + + + + Fold a function along a particular column of a matrix + + + + + Fold a function along each row of a matrix + + + + + Fold a function down each column of a matrix + + + + + Fold an indexed function over all elements of a matrix + + + + + Fold a function over all elements of a matrix + + + + + Check if a predicate holds for at least one element of a matrix + + + + + Check if a predicate holds for all elements of a matrix + + + + + Check if a predicate holds for at least one element of a matrix + + + + + Check if a predicate holds for all elements of a matrix + + + + +sqrt(sum(x*x)) of all the elements of a matrix + + + + +Multiply all the elements of a matrix + + + + + Sum all the elements of a matrix + + + + + Generate a new matrix of the same size as the input with random entries + drawn from the range 0..aij. Random numbers are generated using a globally + shared System.Random instance with the initial seed 99. + + + + + Sum of the diagonal elements of a matrix + + + + + Transpose of a matrix. Use also m.Transpose + + + + + Point-wise exponential of a matrix. + + + + + Dot product + + + + + Add two matrices (operator +) + + + + + Point-wise minimum element of two matrices + + + + + Point-wise maximum element of two matrices + + + + + Ensure that a matrix uses dense representation + + + + + Return the first column of a matrix + + + + + Return the first row of a matrix + + + + + Return the element at row 0, column 0 of a matrix + + + + + Create a matrix with one column from the given vector + + + + + Create a matrix with one row from the given row vector + + + + + Create a 1x1 matrix containing the given value + + + + + Return a new array containing the elements of the given matrix + + + + + Create a matrix from the given data + + + + + Create a matrix from the given data + + + + + Create a matrix from the given data + + + + + Create a square matrix with a vector lying on diagonal + + + + + Create a square matrix with the constant 1.0 lying on diagonal + + + + + Create a matrix with all entries zero + + + + + Create a sparse representation matrix with the given entries. Not all + operations are available for sparse matrices, and mutation is not permitted. + If an operation on sparse matrices raises a runtime exception then consider + converting to a dense matrix using to_dense. + + + + + Create a dense representation matrix with the given entries. + + + + + Create a matrix with all entries the given constant + + + + + + + + Set an element of a matrix + + + + + Get an element of a matrix + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Subtract the second matrix from the first, by mutating the first + + + + + Add the second matrix to the first by, mutating the first + + + + + Map the given position-indexed function over a matrix + + + + + Map a function over a matrix + + + + + Create a new matrix that is a copy of the given array + + + + + Return true if an indexed predicate returns true for some value in a matrix + + + + + Return true if an indexed predicate returns true for all values in a matrix + + + + + Return true if a predicate returns true for some value in a matrix + + + + + Return true if a predicate returns true for all values in a matrix + + + + + Fold an indexed function over all elements of a matrix + + + + + Fold a function over all elements of a matrix + + + + + Returns sqrt(sum(norm(x)*(norm(x))) of all the elements of a matrix. + The element type of a matrix must have an associated instance of INormFloat<'T> (see <c>GlobalAssociations</c>) ((else NotSupportedException)). + + + + + Compute the product of the elements in a matrix + + + + + Compute the sum of the elements in a matrix + + + + + Compute the sum of the diagonal of a square matrix + + + + + Return a new matrix which is the transpose of the input matrix + + + + + Sum of the point-wise multiple of the two matrices. + The element type of a matrix must have an associated instance of INumeric<'T> (see <c>GlobalAssociations</c>) ((else NotSupportedException)). + + + + +Take the pointwise maximum of two matrices + + + + +Take the pointwise maximum of two matrices + + + + + Create a matrix containing the given vector along the diagonal. + The element type of a matrix must have an associated instance of INumeric<'T> (see <c>GlobalAssociations</c>) ((else NotSupportedException)). + + + + + Create a square matrix with the one for the element type lying on diagonal + The element type of a matrix must have an associated instance of INumeric<'T> (see <c>GlobalAssociations</c>) ((else NotSupportedException)). + + + + + Create a matrix containing the zero element at each index. + The element type of a matrix must have an associated instance of INumeric<'T> (see <c>GlobalAssociations</c>) ((else NotSupportedException)). + + + + + Create a matrix using a function to compute the item at each index. + The element type of a matrix must have an associated instance of INumeric<'T> (see <c>GlobalAssociations</c>) ((else NotSupportedException)). + The function is passed the dictionary of associated operations in addition to the index pair. + + + + + Create a matrix using a function to compute the item at each index. + + + + + Extract the first column of a matrix + + + + + Extract the first row of a matrix + + + + + Get the element at column zero, row zero + + + + + Create a matrix from a column vector + + + + + Create a matrix from a row vector + + + + + Create a 1x1 matrix containing the given value + + + + + Create a sparse matrix from the given sequence of elements + + + + + Create a dense matrix from the given sequence of elements + + + + + Create a matrix containing the given value at every element. + + + + + Return a new array containing the elements of the given matrix + + + + + Create a matrix from the given data + + + + + Create a matrix from the given data + + + + + Create a matrix from the given data + + + + + Set an element in a matrix. The indexes are given in row/column order. + + + + + Get an element from a matrix. The indexes are given in row/column order. + + + + + Operations to manipulate matrix types carrying + arbitrary element types. The names and types of the operations match those + in the containing module Math.Matrix. + + The numeric operations on the element type (add, zero etc.) are inferred from the type + argument itself. That is, for some operations + the element type of a matrix must have an associated instance of INumeric<'T> + or some more specific numeric association (see <c>GlobalAssociations</c>) ((else NotSupportedException)). + + + + + Operations to manipulate floating + point matrices. The submodule <c>Matrix.Generic</c> contains a + matching set of operations to manipulate matrix types carrying + arbitrary element types. + + + + + Builds a (row) vector from a sequence of floats. + + + + + Builds a (column) vector from a sequence of floats. + + + + + Builds a matrix from a sequence of sequence of floats. + + + + + + + Version of System.Single.NaN that is generic in its units-of-measure + + + Version of System.Single.PositiveInfinity that is generic in its units-of-measure + + + Version of System.Double.NaN that is generic in its units-of-measure + + + Version of System.Double.PositiveInfinity that is generic in its units-of-measure + + + + + + + + + + + + + + + + + + + + + + + + + + + + The identity permutation over any size + + + + + Return a permutation that rotates right by the given distance. If the distance + is negative then a left rotation results. + + + + + Return a permutation that, when applied, maps index 0 to size-1, size-1 to 0 etc. + + + + + Return a swaps the given two elements over any size + + + + + + + + Create a permutation by specifying (source,destination) index pairs. For example, + Permutation(3,[ (0,2);(1,0); (2,1) ]) specifies a permutation that rotates + all elements left one place. Not all elements need be given, e.g. + Permutation(5,[ (1,2);(2,1) |]) specifies a permutation that swaps elements at indexes + 1 and 2. + + + + + + + + Create a permutation by specifying the result of permuting [| 0 .. n-1 |]. For example, + Permutation.ofArray [| 1;2;0 |] specifies a permutation that rotates all elements right one place. + + + + + + + + Unified atomic mass unit + + + + + Electron volt + + + + + Stefan-Boltzmann constant + + + + + Boltzmann constant R/N_A + + + + + Molar gas constant + + + + + Faraday constant + + + + + Avogadro constant + + + + + Rydberg constant + + + + + Fine-structure constant + + + + + Proton mass + + + + + Electron mass + + + + + Conductance quantum 2e^2/h + + + + + Magnetic flux quantum h/2e + + + + + Elementary charge + + + + + Dirac constant, also known as the reduced Planck constant = h/2pi + + + + + Planck constant + + + + + Newtonian constant of gravitation + + + + + electric constant = 1/(mu0 c^2) + + + + + magnetic constant + + + + + speed of light in vacuum + + + + + Fundamental physical constants, with units-of-measure + + + + + + + + + + + + + + + + + Return a new array containing a copy of the elements of the given vector + + + + + Create a vector from an array of double precision floats + + + + + Create a vector from a sequence of numbers + + + + + Create a vector from a list of numbers + + + + + + + + + + + Return a vector of the given length where every entry is zero. + + + + + Create by comprehension + + + + + Create by constant initialization + + + + + Get the dimensions (number of rows) of a column rowvec. + + + + + Set an element of a column rowvec + + + + + Get an element of a column vector + + + + + + + + + + + + + + + + + + + + Return a new array containing a copy of the elements of the given vector + + + + + Create a row vector from an array of elements + + + + + Create a row vector from a sequence of elements + + + + + Create a row vector from a list of elements + + + + + Return a vector of the given length where every entry is zero. + + + + + Create by constant initialization + + + + + Create by comprehension + + + + + Transpose the row vector + + + + + Get the number of rows in a column vector. + + + + + Set an element in a column vector. + + + + + Get an element from a column vector. + + + + + Operations to manipulate row vectors types carrying + arbitrary element types. + + + + + Operations to manipulate floating + point row vectors. These are included for completeness and are + nearly always transposed to column vectors. + + + + + katal, SI unit of catalytic activity + + + + + sievert, SI unit of does equivalent + + + + + gray, SI unit of absorbed dose + + + + + becquerel, SI unit of activity referred to a radionuclide + + + + + lux, SI unit of illuminance + + + + + lumen, SI unit of luminous flux + + + + + henry, SI unit of inductance + + + + + tesla, SI unit of magnetic flux density + + + + + weber, SI unit of magnetic flux + + + + + siemens, SI unit of electric conductance + + + + + ohm, SI unit of electric resistance + + + + + farad, SI unit of capacitance + + + + + volt, SI unit of electric potential difference, electromotive force + + + + + coulomb, SI unit of electric charge, amount of electricity + + + + + watt, SI unit of power, radiant flux + + + + + joule, SI unit of energy, work, amount of heat + + + + + pascal, SI unit of pressure, stress + + + + + newton, SI unit of force + + + + + hertz, SI unit of frequency + + + + + candela, SI unit of luminous intensity + + + + + mole, SI unit of amount of substance + + + + + kelvin, SI unit of thermodynamic temperature + + + + + ampere, SI unit of electric current + + + + + second, SI unit of time + + + + + kilogram, SI unit of mass + + + + + metre (or meter), SI unit of length + + + + + The International System of Units (SI) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Map an indexed function over each element of a vector + + + + + Map a function over each element of a vector + + + + + Copy a vector + + + + + Fold an indexed function over all elements of a vector + + + + + Fold a function over all elements of a vector + + + + + Return true if an indexed predicate returns true for some value in a vector + + + + + Return true if an indexed predicate returns true for all values in a vector + + + + + Return true if a predicate returns true for some value in a vector + + + + + Return true if a predicate returns true for all values in a vector + + + + + Computes the 2-norm of a vector: sqrt(x.Transpose*x). + + + + +Multiply all the elements of a matrix + + + + +Sum all the elements of a vector + + + + +Transpose of a matrix. Use also m.Transpose + + + + +Point-wise exponential of a vector. + + + + +Dot product + + + + + Create a vector that represents a integral mesh over the given range + e.g. range 1 5 = vector [ 1.;2.;3.;4.;5. ] + + + + + Create a vector that represents a mesh over the given range + e.g. rangef (-1.0) 0.5 1.0 = vector [ -1.0; -0.5; 0.0; 0.5; 1.0] + + + + + Return a vector of the given length where every entry is zero. + + + + + Generate a vector of the given length where each entry contains the given value + + + + + Create a 1-element vector + + + + + Return a new array containing a copy of the elements of the given vector + + + + + Create a vector from an array of double precision floats + + + + + Create a vector from a sequence of numbers + + + + + Create a vector from a list of numbers + + + + + Create a vector of a fixed length using a function to compute the initial element values + + + + + Get the dimensions (number of rows) of a column vector. Identical to <c>nrows</c> + + + + + Set an element of a column vector + + + + + Get an element of a column vector + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Map an indexed function over each element of a vector + + + + + Map a function over each element of a vector + + + + + Copy the vector + + + + + Fold an indexed function over all elements of a vector + + + + + Fold a function over all elements of a vector + + + + + Return true if an indexed predicate returns true for some value in a vector + + + + + Return true if an indexed predicate returns true for all values in a vector + + + + + Return true if a predicate returns true for some value in a vector + + + + + Return true if a predicate returns true for all values in a vector + + + + + Computes the 2-norm of a vector: sqrt(x.Transpose*x). + + + + +Multiply all the elements of a matrix + + + + +Sum all the elements of a vector + + + + +Dot product + + + + +Take the pointwise minimum of two vectors + + + + +Take the pointwise maximum of two vectors + + + + + Return a vector of the given length where every entry is zero. + + + + + Generate a vector of the given length where each entry contains the given value + + + + + Return a new array containing a copy of the elements of the given vector + + + + + Create a vector from an array of elements + + + + + Create a 1-element vector + + + + + Create a vector from a sequence of numbers + + + + + Create a vector from a list of numbers + + + + + Creation: useful when the element type has associated operations. + + + + + Creation: general + + + + + Get the dimensions (number of rows) of a column vector. Identical to <c>nrows</c> + + + + + Set an element of a column vector + + + + + Get an element of a column vector + + + + + Operations to manipulate column vectors carrying + arbitrary element types. + + + + + Operations to manipulate floating + point column vectors. The submodule VectorOps.Generic contains a + matching set of operations to manipulate column vectors carrying + arbitrary element types. + + + + + See NativeArray2 + + + + + Get or set an entry in the array + + + + + + + + + + + + + + View a FortranMatrix as a CMatrix. Doesn't actually allocate + a new matirx - just gives a different label to the same bits, and swaps the + row/column count information associated with the bits. + + + + + Get or set an entry in the array + + + + + + + + This type wraps a pointer to a blob of unmanaged memory assumed to contain + a Fortran-style column major two-dimensional matrix of items compatible with the (presumably blittable) + type 'T. The blob of memory must be allocated and managed externally, + e.g. by a computation routine written in C. + + All operations on this type are marked inlined + because the code used to implement the operations is not verifiable. + + Any code that uses these operations will be unverifiable and may + cause memory corruption if not used with extreme care. + + + + + Get or set an entry in the array + + + + + Pointer to the C-style row major two-dimensional array + + + + + Get the number of rows of the native array + + + + + Get the number of columns of the native array + + + + + View a CMatrix as a FortranMatrix. Doesn't actually allocate + a new matirx - just gives a different label to the same bits, and swaps the + row/column count information associated with the bits. + + + + + Get or set an entry in the array + + + + + Creates a C-style row major two-dimensional array from a native pointer, the number of rows and the number of columns. + Nothing is actually copied. + + + + + This type wraps a pointer to a blob of unmanaged memory assumed to contain + a C-style row major two-dimensional matrix of items compatible with the (presumably blittable) + type 'T. The blob of memory must be allocated and managed externally, + e.g. by a computation routine written in C. + + All operations on this type are marked inlined + because the code used to implement the operations is not verifiable. + + Any code that uses these operations will be unverifiable and may + cause memory corruption if not used with extreme care. + + + + + Get or set an entry in the array + + + + + Pointer to the C-style one-dimensional array + + + + + Length of the C-style one-dimensional array + + + + + Get or set an entry in the array + + + + + Creates a C-style one dimensional array from a native pointer and the length of the array + Nothing is actually copied. + + + + + This type wraps a pointer to a blob of unmanaged memory assumed to contain + a C-style one-dimensional array of items compatible with the (presumably blittable) + type 'T. The blob of memory must be allocated and managed externally, + e.g. by a computation routine written in C. + + All operations on this type are marked inlined + because the code used to implement the operations is not verifiable. + + Any code that uses these operations will be unverifiable and may + cause memory corruption if not used with extreme care. + + + + + For native interop. Pin the given object + + + + + For native interop. Pin the given object + + + + + + + + + + + + + + + + + + + + + + + Represents a pinned handle to a structure with an underlying 2D array, i.e. an underlying NativeArray2. + Used when interfacing with native code math libraries such as LAPACK. + + + + + For native interop. Pin the given object + + + + + + + + + + + + + + + + + + + + Represents a pinned handle to a structure with an underlying 1D array, i.e. an underlying NativeArray. + Used when interfacing with native code math libraries such as LAPACK. + + + + + + + + Pin the given ref for the duration of a single call to the given function. A native pointer to + the contents of the ref is passed to the given function. Cleanup the GCHandle associated with the + pin when the function completes, even if an exception is raised. + + + + + + + + Return the name of the argument + + + + + Return the usage help associated with the argument + + + + + Return the argument type and action of the argument + + + + + + + + + + + Prints the help for each argument. + + + + + Parse some of the arguments given by 'argv', starting at the given position + + + + + Parse the arguments given by System.Environment.GetEnvironmentVariables() + according to the argument processing specifications "specs". + Args begin with "-". Non-arguments are passed to "f" in + order. "use" is printed as part of the usage line if an error occurs. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + The spec value describes the action of the argument, + and whether it expects a following parameter. + + + + + Interpret tables for a unicode lexer generated by fslex. + + + + + + + + Interpret tables for a unicode lexer generated by fslex, processing input asynchronously + + + + + The type of tables for an unicode lexer generated by fslex. + + + + + Interpret tables for an ascii lexer generated by fslex. + + + + + + + + Interpret tables for an ascii lexer generated by fslex, processing input asynchronously + + + + + The type of tables for an ascii lexer generated by fslex. + + + + + The start position for the lexeme + + + + + True if the refill of the buffer ever failed , or if explicitly set to true. + + + + + The end position for the lexeme + + + + + The start position for the lexeme + + + + + The length of the matched string + + + + + The matched string + + + + + True if the refill of the buffer ever failed , or if explicitly set to true. + + + + + The end position for the lexeme + + + + + Dynamically typed, non-lexically scoped parameter table + + + + + Fast helper to turn the matched characters into a string, avoiding an intermediate array + + + + + Fetch a particular character in the matched string + + + + + Create a lex buffer suitable for use with a Unicode lexer that reads character inputs from the given text reader + + + + + Create a lex buffer suitable for Unicode lexing that reads characters from the given string + + + + + Create a lex buffer that reads character or byte inputs by using the given function + + + + + Create a lex buffer suitable for Unicode lexing that reads characters from the given array + + + + + + + + Create a lex buffer suitable for byte lexing that reads characters from the given array + + + + + + + + Create a lex buffer suitable for use with ASCII byte lexing that reads byte inputs from the given binary reader + + + + + Create a lex buffer that asynchronously reads character or byte inputs by using the given function + + + + + Remove all input, though don't discard the current lexeme + + + + + Input buffers consumed by lexers generated by <c>fslex.exe </c> + + + + + The absolute offset of the column for the position + + + + + The absolute offset of the beginning of the line + + + + + The line number for the position + + + + + The file name for the position + + + + + Return absolute offset of the start of the line marked by the position + + + + + + + + The line number in the input stream, assuming fresh positions have been updated + using AsNewLinePos() and by modifying the EndPos property of the LexBuffer. + + + + + The file name associated with the input stream. + + + + + Get an arbitrary position, with the empty string as filename, and + + + + + Return the column number marked by the position, i.e. the difference between the AbsoluteOffset and the StartOfLineAbsoluteOffset + + + + + + + + The character number in the input stream + + + + + Gives a position shifted by specified number of characters + + + + + Get a position corresponding to the first line (line number 1) in a given file + + + + + Given a position at the start of a token of length n, return a position just beyond the end of the token + + + + + + + + Position information stored for lexing tokens + + + + + The tag of the error terminal + + + + + The total number of terminals + + + + + This function is used to hold the user specified "parse_error" or "parse_error_rich" functions + + + + + This table is logically part of the Goto table + + + + + The sparse table offsets for the productions active for each state + + + + + The sparse table for the productions active for each state + + + + + The sparse goto table row offsets + + + + + The sparse goto table + + + + + The immediate action table + + + + + The number of symbols for each reduction + + + + + The sparse action table row offsets + + + + + The sparse action table elements + + + + + A function to compute the data carried by a token + + + + + A function to compute the tag of a token + + + + + The token number indicating the end of input + + + + + The reduction table + + + + + Interpret the parser table taking input from the given lexer, using the given lex buffer, and the given start state. + Returns an object indicating the final synthesized value for the parse. + + + + + Tables generated by fsyacc + The type of the tables contained in a file produced by the fsyacc.exe parser generator. + + + + + The stack of state indexes active at the parse error + + + + + The token that would cause a shift at the parse error + + + + + The stack of productions that would be reduced at the parse error + + + + + The tokens that would cause a reduction at the parse error + + + + + The state active at the parse error + + + + + The message associated with the parse error + + + + + The token that caused the parse error + + + + + The context provided when a parse error occurs + + + + + Get the full range of positions matched by the production + + + + + Get the store of local values associated with this parser + + + + + Raise an error in this parse context + + + + + Get the start position for the terminal or non-terminal at a given index matched by the production + + + + + Get the start and end position for the terminal or non-terminal at a given index matched by the production + + + + + Get the end position for the terminal or non-terminal at a given index matched by the production + + + + + Get the value produced by the terminal or non-terminal at the given position + + + + + The information accessible via the <c>parseState</c> value within parser actions. + + + + + Indicates a parse error has occured and parse recovery is in progress + + + + + + + + Indicates an accept action has occured + + + + + The default implementation of the parse_error function + + + + + The default implementation of the parse_error_rich function + + + + + Helpers used by generated parsers. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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> + + + + + The maximum number of rows for which to generate layout for table-like + structures. -1 if no maximum. + + + + + The maximum number of elements for which to generate layout for + list-like structures, or columns in table-like + structures. -1 if no maximum. + + + + + Return to the layout-generation + environment to layout any otherwise uninterpreted object + + + + + + + + + + + + + + + + + Data representing structured layouts of terms. The representation + of this data type is only for the consumption of formatting engines. + + + + + + + + + + + + + + Data representing joints in structured layouts of terms. The representation + of this data type is only for the consumption of formatting engines. + + + + + 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. + + + + diff --git a/packages/FSPowerPack.Community.2.0.0.0/Tools/fshtmldoc.exe b/packages/FSPowerPack.Community.2.0.0.0/Tools/fshtmldoc.exe new file mode 100644 index 0000000000000000000000000000000000000000..3e4c52d7af7736f8051cf90de034ad427903548c Binary files /dev/null and b/packages/FSPowerPack.Community.2.0.0.0/Tools/fshtmldoc.exe differ diff --git a/packages/FSPowerPack.Community.2.0.0.0/Tools/fslex.exe b/packages/FSPowerPack.Community.2.0.0.0/Tools/fslex.exe new file mode 100644 index 0000000000000000000000000000000000000000..1d92619948a791db109137e437661fe732421092 Binary files /dev/null and b/packages/FSPowerPack.Community.2.0.0.0/Tools/fslex.exe differ diff --git a/packages/FSPowerPack.Community.2.0.0.0/Tools/fsyacc.exe b/packages/FSPowerPack.Community.2.0.0.0/Tools/fsyacc.exe new file mode 100644 index 0000000000000000000000000000000000000000..1ad91ad1de20b524a99637a5333acb8ea2a45261 Binary files /dev/null and b/packages/FSPowerPack.Community.2.0.0.0/Tools/fsyacc.exe differ