{mutable actions:((unit-> unit)*(unit-> unit)) list}

static memberNew()={ actions=[]}

membert.Undo()= List.iter(fun(_,a)-> a()) t.actions

membert.Push f undo= t.actions<-(f, undo):: t.actions

| NoTrace

| WithTraceofTrace

memberx.HasTrace=match xwith NoTrace->false| WithTrace_->true

match twith

| WithTrace trace-> trace.Push f undo; f()

| NoTrace-> f()

source.actions|> List.rev|>

match twith

| WithTrace trace-> List.iter(fun(action,undo)-> trace.Push action undo; action())

| NoTrace-> List.iter(fun(action,_)-> action())

letnewTrace= Trace.New()

letres= f newTrace

lettrace= Trace.New()

letres= f trace

trace.Undo();

trace.Undo()

res

meths|> List.choose(fun calledMeth->

meths

|> List.choose(fun calledMeth->

lettrace= Trace.New()

letres= f trace calledMeth

trace.Undo()

matchres|>CheckNoErrorsAndGetWarningswith

match CheckNoErrorsAndGetWarnings reswith

| None-> None

| Some warns-> Some(calledMeth,warns.Length,trace))

|(v',e')::vs'->

if PreferUnifyTypar v v'

then(v, e):: vs

else(v',e')::(v,e):: vs'

else(v',e')::(v,e):: vs'

find vs

letWarnD err= OkResult([err],())

letCompleteD= OkResult([],())

letResultD x= OkResult([],x)

letCheckNoErrorsAndGetWarnings res=match reswith OkResult(warns,_)-> Some warns| ErrorResult_-> None

match reswith

| OkResult(warns,_)-> Some warns

| ErrorResult_-> None

match reswith

| OkResult([],res)->(* tailcall*) f res

| OkResult(warns,res)->

beginmatch f reswith

match f reswith

| OkResult(warns2,res2)-> OkResult(warns@warns2, res2)

| ErrorResult(warns2,err)-> ErrorResult(warns@warns2, err)

| ErrorResult(warns,err)->

ErrorResult(warns,err)

let recIterateD f xs=match xswith[]-> CompleteD| h:: t-> f h++(fun()-> IterateD f t)

match xswith

|[]-> CompleteD

| h:: t-> f h++(fun()-> IterateD f t)

let recWhileD gd body=if gd()then body()++(fun()-> WhileD gd body)else CompleteD

letMapD f xs=let recloop acc xs=match xswith[]-> ResultD(List.rev acc)| h:: t-> f h++(fun x-> loop(x::acc) t)in loop[] xs

match xswith

|[]-> ResultD(List.rev acc)

| h:: t-> f h++(fun x-> loop(x::acc) t)

loop[] xs

memberx.Bind(res,k)= res++ k

memberx.Return(res)= ResultD(res)

memberx.ReturnFrom(res)= res

memberx.Returnres= ResultDres

memberx.ReturnFromres= res

memberx.For(seq,k)= IterateD k seq

memberx.While(gd,k)= WhileD gd k

memberx.Zero()= CompleteD

lettrackErrors= TrackErrorsBuilder()

letOptionD f xs=match xswith None-> CompleteD| Some(h)-> f h

match xswith

| None-> CompleteD

| Some h-> f h

| ErrorResult(warns,err)->(OkResult(warns,()))++(fun()-> g err)

| res-> res

let recRepeatWhileD ndeep body= body ndeep++(functiontrue-> RepeatWhileD(ndeep+1) body|false-> CompleteD)

let recRepeatWhileD ndeep body= body ndeep++(fun x->if xthenRepeatWhileD(ndeep+1) bodyelse CompleteD)

letAtLeastOneD f l= MapD f l++(fun res-> ResultD(List.exists id res))

letstringThatIsAProxyForANewlineInFlatErrors=new System.String[|char29|]

letstringThatIsAProxyForANewlineInFlatErrors=new System.String[|char29|]

letNewlineifyErrorString(message:string)= message.Replace(stringThatIsAProxyForANewlineInFlatErrors, Environment.NewLine)