|[]-> None

| h::t->if f hthen Some(h,n)else findi(n+1) f t

if n= List.length lthen lelse

match lwith

|[]-> List.rev acc

| x::xs->if n<=0then List.rev accelse loop(x::acc)(n-1) xs

loop[] n l

match lwith

|_::xs->if n=0then lelse drop(n-1) xs

match lwith

lettys= List.collect snd tstys// link fringes

tss, tys

letvss= List.take callPattern.Length vss// drop excessive tys if callPattern shorter

letvss= List.truncate callPattern.Length vss// drop excessive tys if callPattern shorter

lettstys= List.map2(fun ts vs->letts,tyfringe= zipTSTyp ts(typeOfLambdaArg m vs)in ts,(tyfringe, vs)) callPattern vss

List.unzip tstys

letcallPattern= commonCallPattern callPatterns// common CallPattern

letcallPattern= List.take vss.Length callPattern// restricted to max nArgs

letcallPattern= List.truncate vss.Length callPattern// restricted to max nArgs

letformalCallPattern= decideFormalSuggestedCP g z tys vss

letcallPattern= List.take callPattern.Length formalCallPattern

letcallPattern= List.truncate callPattern.Length formalCallPattern

letcallPattern,tyfringes= zipCallPatternArgTys m g callPattern vss

letcallPattern= minimalCallPattern callPattern

lettyfringes= List.take callPattern.Length tyfringes

lettyfringes= List.truncate callPattern.Length tyfringes

if isTrivialCP callPatternthen

None// no transform

letp= transformedFormals.Length

if(vss.Length< p)then internalError"passBinds: |vss|<p - detuple pass"

letxqNs= List.drop p vss

letx1ps= List.take p vss

letx1ps= List.truncate p vss

lety1Ps= List.concat(List.map2 transFormal transformedFormals x1ps)

letformals= y1Ps@ xqNs

match restwith

|[]-> wholem

letids= List.take(max0(lid.Length- rest.Length)) lid

letids= List.truncate(max0(lid.Length- rest.Length)) lid

match idswith

|[]-> wholem

|_-> rangeOfLid ids

match System.Int32.TryParse(rightMost, System.Globalization.NumberStyles.Integer, System.Globalization.CultureInfo.InvariantCulture)with

|true, n-> n

ilTyparSubst|> List.rev|> List.take numParms|> List.rev

ilTyparSubst|> List.rev|> List.truncate numParms|> List.rev

match typwith

letnDetupArgsL= detupArgsL.Length

letnShapes= min nargs nDetupArgsL

List.take nShapes detupArgsL

List.truncate nShapes detupArgsL

|> List.map(fun detupArgs->

match detupArgswith

|[]|[_]-> UnknownValue

if curriedArgs.Length< curriedArgInfos.Length||

((List.take curriedArgInfos.Length curriedArgs,curriedArgInfos)||> List.exists2(fun arg argInfo->

((List.truncate curriedArgInfos.Length curriedArgs,curriedArgInfos)||> List.exists2(fun arg argInfo->

(argInfo.Length>(tryDestRefTupleExpr arg).Length)))

if verboseCReflectthen

elifnot(sigArgInfos.Length<= implArgInfos.Length&& List.forall2(fun x y-> List.length x<= List.length y) sigArgInfos(List.truncate sigArgInfos.Length implArgInfos))then

err(fun(x,y,z)-> FSComp.SR.ValueNotContainedMutabilityAritiesDiffer(x, y, z, id.idText, string sigArgInfos.Length, id.idText, id.idText))

letimplArgInfos= implArgInfos|> List.take sigArgInfos.Length

letimplArgInfos=(implArgInfos, sigArgInfos)||> List.map2(fun l1 l2-> l1|> List.take l2.Length)

letimplArgInfos= implArgInfos|> List.truncate sigArgInfos.Length

letimplArgInfos=(implArgInfos, sigArgInfos)||> List.map2(fun l1 l2-> l1|> List.truncate l2.Length)

if not (isAppTy cenv.g typ) then error(Error(FSComp.SR.tcTypeHasNoNestedTypes(), mWholeTypeApp))

match typ with

| TType_app(tcref, tinst) ->

let pathTypeArgs = List.take (max (tinst.Length - tcref.Typars(mWholeTypeApp).Length) 0) tinst

let pathTypeArgs = List.truncate (max (tinst.Length - tcref.Typars(mWholeTypeApp).Length) 0) tinst

TcTypeApp cenv newOk checkCxs occ env tpenv mWholeTypeApp tcref pathTypeArgs tyargs

| _ -> error(InternalError("TcNestedTypeApplication: expected type application", mWholeTypeApp))

let args = match args with SynConstructorArgs.Pats args -> args | _ -> failwith "impossible: active patterns can be used only with SynConstructorArgs.Pats"

let e =

if dotms.Length = longId.Length then

let e = SynExpr.LongIdent(false, LongIdentWithDots(longId, List.take (dotms.Length - 1) dotms), None, m)

let e = SynExpr.LongIdent(false, LongIdentWithDots(longId, List.truncate (dotms.Length - 1) dotms), None, m)

SynExpr.DiscardAfterMissingQualificationAfterDot(e, unionRanges e.Range (List.last dotms))

else SynExpr.LongIdent(false, lidwd, None, m)

List.fold (fun f x -> mkSynApp1 f (convSynPatToSynExpr x) m) e args

let thisValOpt = GetInstanceMemberThisVariable (v, x)

// Members have at least as many type parameters as the enclosing class. Just grab the type variables for the type.

let thisTyInst = List.map mkTyparTy (List.take (tcref.Typars(v.Range).Length) v.Typars)

let thisTyInst = List.map mkTyparTy (List.truncate (tcref.Typars(v.Range).Length) v.Typars)

let x = localReps.FixupIncrClassExprPhase2C cenv thisValOpt safeStaticInitInfo thisTyInst x

| LongIdentWithDots([],_)-> failwith"rangeOfLidwd"

| LongIdentWithDots([id],_)-> id.idRange

| LongIdentWithDots(h::t,dotms)->

letnonExtraDots=if dotms.Length= t.Lengththen dotmselse List.take t.Length dotms

letnonExtraDots=if dotms.Length= t.Lengththen dotmselse List.truncate t.Length dotms

unionRanges h.idRange(List.last t).idRange|> unionRanges(List.last nonExtraDots)

if curriedArgs.Length< curriedArgInfos.Length||

((List.take curriedArgInfos.Length curriedArgs, curriedArgInfos)||> List.exists2(fun arg argInfo->(argInfo.Length>(tryDestRefTupleExpr arg).Length)))then

((List.truncate curriedArgInfos.Length curriedArgs, curriedArgInfos)||> List.exists2(fun arg argInfo->(argInfo.Length>(tryDestRefTupleExpr arg).Length)))then