|[]-> None

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

if n= List.length lthen(l,[])else// avoids allocation unless necessary

if n<=0then(List.rev acc,l)else

match lwith

|[]-> failwith"List.chop: overchop"

|(h::t)-> loop(n-1) t(h::acc)

loop n l[]

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

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

letparentTypars= parentTcref.TyparsNoRange

letnumParentTypars= parentTypars.Length

if tps.Length< numParentTyparsthen error(InternalError("CodeGen check: type checking did not ensure that this method is sufficiently generic", m))

letctps,mtps= List.chop numParentTypars tps

letctps,mtps= List.splitAt numParentTypars tps

letisCompiledAsInstance= ValRefIsCompiledAsInstanceMember g vref

| Method(topValInfo,vref,mspec,_,_,_,_)->

let_,curriedArgInfos,_,_= GetTopValTypeInFSharpForm cenv.g topValInfo vref.Type m

List.chop curriedArgInfos.Length args

List.splitAt curriedArgInfos.Length args

letactualRetTy= applyTys cenv.g vref.Type(tyargs,nowArgs)

let_,curriedArgInfos,returnTy,_= GetTopValTypeInCompiledForm cenv.g topValInfo vref.Type m

if ilTyArgs.Length< numEnclILTypeArgsthen error(InternalError("length mismatch",m))

List.chop numEnclILTypeArgs ilTyArgs

List.splitAt numEnclILTypeArgs ilTyArgs

letboxity= mspec.DeclaringType.Boxity

letmspec= mkILMethSpec(mspec.MethodRef, boxity,ilEnclArgTys,ilMethArgTys)

lettps,vss,b,rty= stripTopLambda(b,f.Type)

letvssTake,vssDrop= List.chop wf vss

letvssTake,vssDrop= List.splitAt wf vss

letb,rty= mkMultiLambdasCore b.Range vssDrop(b,rty)

letnUnnamedCallerArgs= unnamedCallerArgs.Length

letnUnnamedCalledArgs= unnamedCalledArgs.Length

if allowOutAndOptArgs&& nUnnamedCallerArgs< nUnnamedCalledArgsthen

letunnamedCalledArgsTrimmed,unnamedCalledOptOrOutArgs= List.chop nUnnamedCallerArgs unnamedCalledArgs

letunnamedCalledArgsTrimmed,unnamedCalledOptOrOutArgs= List.splitAt nUnnamedCallerArgs unnamedCalledArgs

if unnamedCalledOptOrOutArgs|> List.forall(fun x-> x.IsOutArg&& isByrefTy g x.CalledArgumentType)then

if supportsParamArgs&& unnamedCallerArgs.Length>= minArgsthen

leta,b= List.frontAndBack unnamedCalledArgs

List.chop minArgs unnamedCallerArgs, a, Some(b)

List.splitAt minArgs unnamedCallerArgs, a, Some(b)

(unnamedCallerArgs,[]), unnamedCalledArgs, None

|1,[]-> error(InternalError("expected additional arguments here", m))

if args.Length< aritythen error(InternalError("internal error in getting arguments, n ="+string arity+", #args ="+string args.Length, m));

lettupargs,argst= List.chop arity args

lettupargs,argst= List.splitAt arity args

lettuptys= tupargs|> List.map(tyOfExpr g)

(mkRefTupled g m tupargs tuptys),

(argst, rangeOfFunTy g fty))

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 tywith

letnDetupArgsL= detupArgsL.Length

letnShapes= min nargs nDetupArgsL

List.take nShapes detupArgsL

List.truncate nShapes detupArgsL

|> List.map(fun detupArgs->

match detupArgswith

|[]|[_]-> UnknownValue

letnCurriedArgInfos= curriedArgInfos.Length

if curriedArgs.Length< nCurriedArgInfos||

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

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

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

if verboseCReflectthen

ConvExpr cenv env(MakeApplicationAndBetaReduce cenv.g(expr,exprty,[tyargs],curriedArgs,m))

let(curriedArgs:Expr list),laterArgs= List.chop nCurriedArgInfos curriedArgs

let(curriedArgs:Expr list),laterArgs= List.splitAt nCurriedArgInfos curriedArgs

err(fun(x,y,z)-> FSComp.SR.ValueNotContainedMutabilityGenericParametersDiffer(x, y, z, string mtps, string ntps))

elif implValInfo.KindsOfTypars<> sigValInfo.KindsOfTyparsthen

err(FSComp.SR.ValueNotContainedMutabilityGenericParametersAreDifferentKinds)

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

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

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

letimplArgInfos= implArgInfos|> List.take nSigArgInfos

letimplArgInfos= implArgInfos|> List.truncate nSigArgInfos

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