<dataname="typrelCannotResolveImplicitGenericInstantiation"xml:space="preserve">

<value>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. '{0}' and '{1}'. Consider using type annotations to resolve the ambiguity</value>

</data>

<dataname="typrelCannotResolveAmbiguityInOverloadedOperator"xml:space="preserve">

<value>Could not resolve the ambiguity inherent in the use of the operator '{0}' at or near this program point. Consider using type annotations to resolve the ambiguity.</value>

</data>

<dataname="typrelCannotResolveAmbiguityInPrintf"xml:space="preserve">

<value>Could not resolve the ambiguity inherent in the use of a 'printf'-style format string</value>

</data>

<dataname="tcTupleMemberNotNormallyUsed"xml:space="preserve">

<value>This method or property is not normally used from F# code, use an explicit tuple pattern for deconstruction instead.</value>

</data>

<dataname="implicitlyDiscardedInSequenceExpression"xml:space="preserve">

<value>This expression returns a value of type '{0}' but is implicitly discarded. Consider using 'let' to bind the result to a name, e.g. 'let result = expression'. If you intended to use the expression as a value in the sequence then use an explicit 'yield'.</value>

</data>

<dataname="implicitlyDiscardedSequenceInSequenceExpression"xml:space="preserve">

<value>This expression returns a value of type '{0}' but is implicitly discarded. Consider using 'let' to bind the result to a name, e.g. 'let result = expression'. If you intended to use the expression as a value in the sequence then use an explicit 'yield!'.</value>

</data>

</root>

os.Append(System.Environment.NewLine+ FSComp.SR.derefInsteadOfNot())|> ignore

|_-> os.Append(ErrorFromAddingTypeEquation1E().Format t2 t1 tpcs)|> ignore

| ErrorFromAddingTypeEquation(_,_,_,_,((ConstraintSolverTypesNotInEqualityRelation(_,_,_,_,_, contextInfo))as e),_)when contextInfo<> ContextInfo.NoContext->

| ErrorFromAddingTypeEquation(_,_,_,_,((ConstraintSolverTypesNotInEqualityRelation(_,_,_,_,_, contextInfo))as e),_)when(matchcontextInfowith ContextInfo.NoContext->false|_->true)->

OutputExceptionR os e

| ErrorFromAddingTypeEquation(_,_,_,_,((ConstraintSolverTypesNotInSubsumptionRelation_| ConstraintSolverError_)as e),_)->

| FollowingPatternMatchClauseofrange

| PatternMatchGuardofrange

| SequenceExpressionofTType

exception ConstraintSolverTupleDiffLengthsofDisplayEnv*TTypelist*TTypelist*range*range

exception ConstraintSolverInfiniteTypesofContextInfo*DisplayEnv*TType*TType*range*range

| FollowingPatternMatchClauseofrange

| PatternMatchGuardofrange

| SequenceExpressionofTType

exception ConstraintSolverTupleDiffLengthsofDisplayEnv*TTypelist*TTypelist*range*range

exception ConstraintSolverInfiniteTypesofContextInfo*DisplayEnv*TType*TType*range*range

3218,ArgumentsInSigAndImplMismatch,"The argument names in the signature '%s' and implementation '%s' do not match. The argument name from the signature file will be used. This may cause problems when debugging or profiling."

3219,pickleUnexpectedNonZero,"An error occurred while reading the F# metadata of assembly '%s'. A reserved construct was utilized. You may need to upgrade your F# compiler or use an earlier version of the assembly that doesn't make use of a specific construct."

3220,tcTupleMemberNotNormallyUsed,"This method or property is not normally used from F# code, use an explicit tuple pattern for deconstruction instead."

3221,implicitlyDiscardedInSequenceExpression,"This expression returns a value of type '%s' but is implicitly discarded. Consider using 'let' to bind the result to a name, e.g. 'let result = expression'. If you intended to use the expression as a value in the sequence then use an explicit 'yield'."

3222,implicitlyDiscardedSequenceInSequenceExpression,"This expression returns a value of type '%s' but is implicitly discarded. Consider using 'let' to bind the result to a name, e.g. 'let result = expression'. If you intended to use the expression as a value in the sequence then use an explicit 'yield!'."

| ContextInfo.ReturnInComputationExpression

| ContextInfo.YieldInComputationExpression

| ContextInfo.RuntimeTypeTest _

| ContextInfo.DowncastUsedInsteadOfUpcast _ ->

| ContextInfo.DowncastUsedInsteadOfUpcast _

| ContextInfo.SequenceExpression _ ->

env

| ContextInfo.CollectionElement (b,m) ->

if m <> oldRange then env else

extractNext inner

| expr -> checkExpr m expr

let UnifyUnitType cenv denv m ty expr =

let UnifyUnitType cenv (env:TcEnv) m ty expr =

let denv = env.DisplayEnv

if AddCxTypeEqualsTypeUndoIfFailed denv cenv.css m ty cenv.g.unit_ty then

true

else

let domainTy = NewInferenceType ()

let resultTy = NewInferenceType ()

if AddCxTypeEqualsTypeUndoIfFailed denv cenv.css m ty (domainTy --> resultTy) then

warning (FunctionValueUnexpected(denv, ty, m))

else

if not (typeEquiv cenv.g cenv.g.bool_ty ty) then

warning (UnitTypeExpected (denv, ty, m))

else

warning (ReportImplicitlyIgnoredBoolExpression denv m ty expr)

else

let reportImplicitlyDiscardError() =

if typeEquiv cenv.g cenv.g.bool_ty ty then

warning (ReportImplicitlyIgnoredBoolExpression denv m ty expr)

else

warning (UnitTypeExpected (denv, ty, m))

match env.eContextInfo with

| ContextInfo.SequenceExpression seqTy ->

let lifted = mkSeqTy cenv.g ty

if typeEquiv cenv.g seqTy lifted then

warning (Error (FSComp.SR.implicitlyDiscardedInSequenceExpression(NicePrint.prettyStringOfTy denv ty), m))

else

if isListTy cenv.g ty || isArrayTy cenv.g ty || typeEquiv cenv.g seqTy ty then

warning (Error (FSComp.SR.implicitlyDiscardedSequenceInSequenceExpression(NicePrint.prettyStringOfTy denv ty), m))

else

reportImplicitlyDiscardError()

| _ ->

reportImplicitlyDiscardError()

false

//-------------------------------------------------------------------------

and TcStmt cenv env tpenv synExpr =

let expr, ty, tpenv = TcExprOfUnknownType cenv env tpenv synExpr

let m = synExpr.Range

let wasUnit = UnifyUnitType cenv env.DisplayEnv m ty expr

let wasUnit = UnifyUnitType cenv env m ty expr

if wasUnit then

expr, tpenv

else

// seq { ...; expr } is treated as 'seq { ... ; expr; yield! Seq.empty }'

// Note this means seq { ...; () } is treated as 'seq { ... ; (); yield! Seq.empty }'

let m = comp.Range

let env = { env with eContextInfo = ContextInfo.SequenceExpression genOuterTy }

let expr, tpenv = TcStmtThatCantBeCtorBody cenv env tpenv comp

Expr.Sequential(expr, mkSeqEmpty cenv env m genOuterTy, NormalSeq, SuppressSequencePointOnStmtOfSequential, m), tpenv

else TcExprThatCantBeCtorBody cenv overallExprTy envinner tpenv rhsExpr)

if bkind = StandaloneExpression && not cenv.isScript then

UnifyUnitType cenv env.DisplayEnv mBinding overallPatTy rhsExprChecked |> ignore<bool>

UnifyUnitType cenv env mBinding overallPatTy rhsExprChecked |> ignore<bool>

// Fix up the r.h.s. expression for 'fixed'

let rhsExprChecked =

<targetstate="translated">Tato metoda nebo vlastnost se obvykle z kódu F# nepoužívá, použijte místo toho pro dekonstrukci explicitní vzor řazené kolekce členů.</target>

<note />

</trans-unit>

<trans-unitid="implicitlyDiscardedInSequenceExpression">

<source>This expression returns a value of type '{0}' but is implicitly discarded. Consider using 'let' to bind the result to a name, e.g. 'let result = expression'. If you intended to use the expression as a value in the sequence then use an explicit 'yield'.</source>

<targetstate="new">This expression returns a value of type '{0}' but is implicitly discarded. Consider using 'let' to bind the result to a name, e.g. 'let result = expression'. If you intended to use the expression as a value in the sequence then use an explicit 'yield'.</target>

<note />

</trans-unit>

<trans-unitid="implicitlyDiscardedSequenceInSequenceExpression">

<source>This expression returns a value of type '{0}' but is implicitly discarded. Consider using 'let' to bind the result to a name, e.g. 'let result = expression'. If you intended to use the expression as a value in the sequence then use an explicit 'yield!'.</source>

<targetstate="new">This expression returns a value of type '{0}' but is implicitly discarded. Consider using 'let' to bind the result to a name, e.g. 'let result = expression'. If you intended to use the expression as a value in the sequence then use an explicit 'yield!'.</target>

<note />

</trans-unit>

</body>

</file>

</xliff>

<targetstate="translated">Diese Methode oder Eigenschaft wird normalerweise nicht im F#-Code verwendet. Nutzen Sie stattdessen zur Dekonstruktion ein explizites Tupelmuster.</target>

<note />

</trans-unit>

<trans-unitid="implicitlyDiscardedInSequenceExpression">

<source>This expression returns a value of type '{0}' but is implicitly discarded. Consider using 'let' to bind the result to a name, e.g. 'let result = expression'. If you intended to use the expression as a value in the sequence then use an explicit 'yield'.</source>

<targetstate="new">This expression returns a value of type '{0}' but is implicitly discarded. Consider using 'let' to bind the result to a name, e.g. 'let result = expression'. If you intended to use the expression as a value in the sequence then use an explicit 'yield'.</target>

<note />

</trans-unit>

<trans-unitid="implicitlyDiscardedSequenceInSequenceExpression">

<source>This expression returns a value of type '{0}' but is implicitly discarded. Consider using 'let' to bind the result to a name, e.g. 'let result = expression'. If you intended to use the expression as a value in the sequence then use an explicit 'yield!'.</source>

<targetstate="new">This expression returns a value of type '{0}' but is implicitly discarded. Consider using 'let' to bind the result to a name, e.g. 'let result = expression'. If you intended to use the expression as a value in the sequence then use an explicit 'yield!'.</target>

<note />

</trans-unit>

</body>

</file>

</xliff>

<targetstate="new">This method or property is not normally used from F# code, use an explicit tuple pattern for deconstruction instead.</target>

<note />

</trans-unit>

<trans-unitid="implicitlyDiscardedInSequenceExpression">

<source>This expression returns a value of type '{0}' but is implicitly discarded. Consider using 'let' to bind the result to a name, e.g. 'let result = expression'. If you intended to use the expression as a value in the sequence then use an explicit 'yield'.</source>

<targetstate="new">This expression returns a value of type '{0}' but is implicitly discarded. Consider using 'let' to bind the result to a name, e.g. 'let result = expression'. If you intended to use the expression as a value in the sequence then use an explicit 'yield'.</target>

<note />

</trans-unit>

<trans-unitid="implicitlyDiscardedSequenceInSequenceExpression">

<source>This expression returns a value of type '{0}' but is implicitly discarded. Consider using 'let' to bind the result to a name, e.g. 'let result = expression'. If you intended to use the expression as a value in the sequence then use an explicit 'yield!'.</source>

<targetstate="new">This expression returns a value of type '{0}' but is implicitly discarded. Consider using 'let' to bind the result to a name, e.g. 'let result = expression'. If you intended to use the expression as a value in the sequence then use an explicit 'yield!'.</target>

<note />

</trans-unit>

</body>

</file>

</xliff>