internal static CommandBinding CreateComplexNormalBinding(
string name,
Func <KeyInput, bool> predicate,
KeyRemapMode remapMode = null,
CommandFlags flags = CommandFlags.None)
{
var remapModeOption = FSharpOption.CreateForReference(remapMode);
Func <KeyInput, BindResult <NormalCommand> > func = null;
func = keyInput =>
{
if (predicate(keyInput))
{
var data = new BindData <NormalCommand>(
remapModeOption,
func.ToFSharpFunc());
return(BindResult <NormalCommand> .NewNeedMoreInput(data));
}
return(BindResult <NormalCommand> .NewComplete(NormalCommand.NewPutAfterCaret(false)));
};
var bindData = new BindData <NormalCommand>(
remapModeOption,
func.ToFSharpFunc());
var bindDataStorage = BindDataStorage <NormalCommand> .NewSimple(bindData);
return(CommandBinding.NewComplexNormalBinding(
KeyNotationUtil.StringToKeyInputSet(name),
flags,
bindDataStorage));
}
public void Create_GetFromCache()
{
var runCount = 0;
Func <IClassifier> func =
() =>
{
runCount++;
return(_factory.Create <IClassifier>().Object);
};
var result1 = new CountedClassifier(_propertyCollection, _key, func.ToFSharpFunc());
var result2 = new CountedClassifier(_propertyCollection, _key, func.ToFSharpFunc());
Assert.Equal(1, runCount);
Assert.Same(result1.Classifier, result2.Classifier);
}
internal static BindData <T> CreateBindData <T>(Func <KeyInput, BindResult <T> > func = null, KeyRemapMode remapMode = null)
{
func = func ?? (x => BindResult <T> .Cancelled);
remapMode = remapMode ?? KeyRemapMode.None;
return(new BindData <T>(remapMode, func.ToFSharpFunc()));
}
internal static Command CreateLongCommand(string name, Func<FSharpOption<int>, Register, LongCommandResult> func, CommandFlags flags = CommandFlags.None)
{
var fsharpFunc = func.ToFSharpFunc();
var list = name.Select(KeyInputUtil.CharToKeyInput).ToFSharpList();
var commandName = KeyInputSet.NewManyKeyInputs(list);
return Command.NewLongCommand(commandName, flags, fsharpFunc);
}
internal static CommandBinding CreateLegacyBinding(string name, Func <FSharpOption <int>, Register, CommandResult> func)
{
var fsharpFunc = func.ToFSharpFunc();
var list = name.Select(KeyInputUtil.CharToKeyInput).ToFSharpList();
var commandName = KeyInputSet.NewManyKeyInputs(list);
return(CommandBinding.NewLegacyBinding(commandName, CommandFlags.None, fsharpFunc));
}
/// <summary>
/// Applies a key-generating function to each element of a CloudFlow and return a CloudFlow yielding unique keys and the result of the threading an accumulator.
/// </summary>
/// <typeparam name="TSource">Source flow element type.</typeparam>
/// <typeparam name="TKey">Element key type.</typeparam>
/// <typeparam name="TState">Accumulated state type.</typeparam>
/// <param name="flow">Source CloudFlow.</param>
/// <param name="projection">Key projection function.</param>
/// <param name="folder">State updater function on the initial inputs.</param>
/// <param name="combiner">State combiner function.</param>
/// <param name="initializer">State initializer function.</param>
/// <returns>A CloudFlow that has grouped accumulated states by key.</returns>
public static CloudFlow <KeyValuePair <TKey, TState> > AggregateBy <TSource, TKey, TState>(this CloudFlow <TSource> flow, Func <TSource, TKey> projection,
Func <TState> initializer,
Func <TState, TSource, TState> folder,
Func <TState, TState, TState> combiner)
{
return(CloudFlowModule
.foldBy(projection.ToFSharpFunc(), folder.ToFSharpFunc(), combiner.ToFSharpFunc(), initializer.ToFSharpFunc(), flow)
.Select(tuple => new KeyValuePair <TKey, TState>(tuple.Item1, tuple.Item2)));
}
internal static CommandBinding CreateNormalBinding(string name, Func <CommandData, CommandResult> func)
{
var fsharpFunc = func.ToFSharpFunc();
var list = name.Select(KeyInputUtil.CharToKeyInput).ToFSharpList();
var commandName = KeyInputSet.NewManyKeyInputs(list);
var command = NormalCommand.NewPing(new PingData(fsharpFunc));
return(CommandBinding.NewNormalBinding(commandName, CommandFlags.None, command));
}
public static FSharpFunc <MotionArgument, FSharpOption <MotionResult> > CreateMotionFunc(Func <int, MotionResult> action)
{
Func <MotionArgument, FSharpOption <MotionResult> > func = arg =>
{
return(FSharpOption.Create(action(arg.Count)));
};
return(func.ToFSharpFunc());
}
public ReplaceTest()
{
_clipboardDevice = new Mock <IClipboardDevice>(MockBehavior.Loose);
Func <FSharpOption <string> > func = () => FSharpOption <string> .None;
_registerMap = new RegisterMap(
new VimData(_globalSettings),
_clipboardDevice.Object,
func.ToFSharpFunc());
}
public static FSharpFunc <MotionArgument, FSharpOption <MotionResult> > CreateMotionFunc(Action <int> action)
{
Func <MotionArgument, FSharpOption <MotionResult> > func = arg =>
{
action(arg.Count);
return(FSharpOption <MotionResult> .None);
};
return(func.ToFSharpFunc());
}
IClassifier IClassifierProvider.GetClassifier(ITextBuffer textBuffer)
{
var classificationType = _classificationTypeRegistryService.GetClassificationType(DirectoryFormatDefinition.Name);
Func <IBasicTaggerSource <IClassificationTag> > func = () => new DirectoryTaggerSource(textBuffer, classificationType);
return(TaggerUtil.CreateBasicClassifier(
textBuffer.Properties,
s_key,
func.ToFSharpFunc()));
}
internal static RegisterMap CreateRegisterMap(IClipboardDevice device, Func <string> func)
{
Func <FSharpOption <string> > func2 = () =>
{
var result = func();
return(string.IsNullOrEmpty(result) ? FSharpOption <string> .None : FSharpOption.Create(result));
};
return(new RegisterMap(new VimData(), device, func2.ToFSharpFunc()));
}
internal static NormalCommand CreatePing(Action <CommandData> action)
{
Func <CommandData, CommandResult> func =
commandData =>
{
action(commandData);
return(CommandResult.NewCompleted(ModeSwitch.NoSwitch));
};
var data = new PingData(func.ToFSharpFunc());
return(NormalCommand.NewPing(data));
}
public static FSharpFunc <MotionArgument, FSharpOption <MotionResult> > CreateMotionFunc(Func <MotionResult> func)
{
Func <MotionArgument, FSharpOption <MotionResult> > inner = arg =>
{
var ret = func();
return(ret != null
? FSharpOption.Create(ret)
: FSharpOption <MotionResult> .None);
};
return(inner.ToFSharpFunc());
}
ITagger <T> IViewTaggerProvider.CreateTagger <T>(ITextView textView, ITextBuffer textBuffer)
{
if (textView.TextBuffer != textBuffer || !_vim.ShouldCreateVimBuffer(textView))
{
return(null);
}
Func <IBasicTaggerSource <IntraTextAdornmentTag> > func = () => CreateCharDisplayTaggerSource(textView);
return(TaggerUtil.CreateBasicTagger(
textView.Properties,
_key,
func.ToFSharpFunc()) as ITagger <T>);
}
public void UsingFSharpFuncIfYouHaveTo()
{
// These are all using the module functions.
// Module is just a static class to C#.
var list = RecursiveList.EmptyList <string>();
var listWithAddedData = RecursiveList.cons("Test", list);
Func <string, string> mapFunction = s => "TEST2" + s;
var fsharpFunc = mapFunction.ToFSharpFunc();
var mappedList = RecursiveList.map(fsharpFunc, listWithAddedData);
var expectedList = RecursiveList <string> .NewHead("TEST2Test", RecursiveList <string> .Empty);
Assert.AreEqual(expectedList, mappedList);
}
public void Create_DoCreate()
{
var didRun = false;
Func <IClassifier> func =
() =>
{
didRun = true;
return(_factory.Create <IClassifier>().Object);
};
var result = new CountedClassifier(
_propertyCollection,
_key,
func.ToFSharpFunc());
Assert.True(didRun);
}
public void LoadVimRc3()
{
// Setup the VimRc contents
var fileName = "foo";
var contents = new string[] { "set ai" };
var tuple = Tuple.Create(fileName, contents);
_fileSystem.Setup(x => x.GetVimRcDirectories()).Returns(new string[] { "" }).Verifiable();
_fileSystem.Setup(x => x.LoadVimRc()).Returns(FSharpOption.Create(tuple)).Verifiable();
Func <ITextView> createViewFunc = () => EditorUtil.CreateTextView();
Assert.IsTrue(_vim.LoadVimRc(createViewFunc.ToFSharpFunc()));
Assert.IsTrue(_vim.VimRcLocalSettings.AutoIndent);
_fileSystem.Verify();
}
void StartFaceDetection_Pipeline_FSharpFunc(string imagesFolder)
{
var files = Directory.GetFiles(ImagesFolder);
Func <string, Image <Bgr, byte> > imageFn =
(fileName) => new Image <Bgr, byte>(fileName);
Func <Image <Bgr, byte>, Tuple <Image <Bgr, byte>, Image <Gray, byte> > > grayFn =
image => Tuple.Create(image, image.Convert <Gray, byte>());
Func <Tuple <Image <Bgr, byte>, Image <Gray, byte> >,
Tuple <Image <Bgr, byte>, System.Drawing.Rectangle[]> > detectFn =
frames => Tuple.Create(frames.Item1,
CascadeClassifierThreadLocal.Value.DetectMultiScale(
frames.Item2, 1.1, 3, System.Drawing.Size.Empty));
Func <Tuple <Image <Bgr, byte>, System.Drawing.Rectangle[]>, Bitmap> drawFn =
faces =>
{
foreach (var face in faces.Item2)
{
faces.Item1.Draw(face, new Bgr(System.Drawing.Color.BurlyWood), 3);
}
return(faces.Item1.ToBitmap());
};
var imagePipe =
Pipeline <string, Image <Bgr, byte> >
.Create(imageFn.ToFSharpFunc())
.Then(grayFn.ToFSharpFunc())
.Then(detectFn.ToFSharpFunc())
.Then(drawFn.ToFSharpFunc()); // #A
CancellationTokenSource cts = new CancellationTokenSource();
imagePipe.Execute(4, cts.Token); // #B
foreach (string fileName in files)
{
imagePipe.Enqueue(fileName,
FSharpFuncUtils.Create <Tuple <string, Bitmap>, Unit>
((tup) =>
{
Application.Current.Dispatcher.Invoke(
() => Images.Add(tup.Item2.ToBitmapImage()));
return((Unit)Activator.CreateInstance(typeof(Unit), true));
})); // #C
}
}
/// <summary>
/// Try and process the given KeyInput for insert mode in the middle of an Exec. This is
/// called for commands which can't be processed directly like edits. We'd prefer these
/// go through Visual Studio's command system so items like Intellisense work properly.
/// </summary>
private bool TryProcessWithExec(Guid commandGroup, OleCommandData oleCommandData, IInsertMode insertMode, KeyInput originalKeyInput, KeyInput mappedKeyInput)
{
Func <bool> customProcess =
() =>
{
var versionNumber = _textBuffer.CurrentSnapshot.Version.VersionNumber;
int? hr = null;
Guid mappedCommandGroup;
OleCommandData mappedOleCommandData;
if (originalKeyInput == mappedKeyInput)
{
// No changes so just use the original OleCommandData
hr = _nextTarget.Exec(
ref commandGroup,
oleCommandData.CommandId,
oleCommandData.CommandExecOpt,
oleCommandData.VariantIn,
oleCommandData.VariantOut);
}
else if (OleCommandUtil.TryConvert(mappedKeyInput, out mappedCommandGroup, out mappedOleCommandData))
{
hr = _nextTarget.Exec(
ref mappedCommandGroup,
mappedOleCommandData.CommandId,
mappedOleCommandData.CommandExecOpt,
mappedOleCommandData.VariantIn,
mappedOleCommandData.VariantOut);
OleCommandData.Release(ref mappedOleCommandData);
}
if (hr.HasValue)
{
// Whether or not an Exec succeeded is a bit of a heuristic. IOleCommandTarget implementations like
// C++ will return E_ABORT if Intellisense failed but the character was actually inserted into
// the ITextBuffer. VsVim really only cares about the character insert. However we must also
// consider cases where the character successfully resulted in no action as a success
return(ErrorHandler.Succeeded(hr.Value) || versionNumber < _textBuffer.CurrentSnapshot.Version.VersionNumber);
}
// Couldn't map to a Visual Studio command so it didn't succeed
return(false);
};
return(insertMode.CustomProcess(mappedKeyInput, customProcess.ToFSharpFunc()));
}
private void MaybeLoadVimRc()
{
if (!_vim.IsVimRcLoaded && String.IsNullOrEmpty(_vim.Settings.VimRcPaths))
{
// Need to pass the LoadVimRc call a function to create an ITextView that
// can be used to load the settings against. We don't want this ITextView
// coming back through TextViewCreated so give it a ITextViewRole that won't
// hit our filter
Func <ITextView> createViewFunc = () => _editorFactoryService.CreateTextView(
_bufferFactoryService.CreateTextBuffer(),
_editorFactoryService.NoRoles);
if (!_vim.LoadVimRc(_fileSystem, createViewFunc.ToFSharpFunc()))
{
// If no VimRc file is loaded add a couple of sanity settings
_vim.VimRcLocalSettings.AutoIndent = true;
}
}
}
ITagger <T> IViewTaggerProvider.CreateTagger <T>(ITextView textView, ITextBuffer textBuffer)
{
if (textView.TextBuffer != textBuffer)
{
return(null);
}
if (!_vim.TryGetOrCreateVimBufferForHost(textView, out IVimBuffer vimBuffer))
{
return(null);
}
var vimBufferData = vimBuffer.VimBufferData;
Func <IBasicTaggerSource <MarkGlyphTag> > func =
() => CreateMarkGlyphTaggerSource(vimBufferData);
return(TaggerUtil.CreateBasicTagger(
textView.Properties,
_key,
func.ToFSharpFunc()) as ITagger <T>);
}
internal static CommandBinding CreateComplexNormalBinding(
string name,
Action <KeyInput> action,
CommandFlags flags = CommandFlags.None)
{
Func <KeyInput, BindResult <NormalCommand> > func = keyInput =>
{
action(keyInput);
return(BindResult <NormalCommand> .NewComplete(NormalCommand.NewPutAfterCaret(false)));
};
var bindData = new BindData <NormalCommand>(
FSharpOption <KeyRemapMode> .None,
func.ToFSharpFunc());
var bindDataStorage = BindDataStorage <NormalCommand> .NewSimple(bindData);
return(CommandBinding.NewComplexNormalBinding(
KeyNotationUtil.StringToKeyInputSet(name),
flags,
bindDataStorage));
}
public void Dispose_ManyInstance()
{
var tagger = _factory.Create <IClassifier>();
var disposable = tagger.As <IDisposable>();
Func <IClassifier> func = () => tagger.Object;
var result1 = new CountedClassifier(_propertyCollection, _key, func.ToFSharpFunc());
var result2 = new CountedClassifier(_propertyCollection, _key, func.ToFSharpFunc());
result1.Dispose();
disposable.Setup(x => x.Dispose()).Verifiable();
result2.Dispose();
disposable.Verify();
}
private CountedTagger <TextMarkerTag> Create(object key, PropertyCollection propertyCollection, Func <ITagger <TextMarkerTag> > func)
{
return(new CountedTagger <TextMarkerTag>(propertyCollection, key, func.ToFSharpFunc()));
}
private CommandRunData CreateCommand(
Func<FSharpOption<int>, Register, CommandResult> func = null,
KeyInputSet name = null,
CommandFlags? flags = null,
int? count = 0,
MotionRunData motionRunData = null,
VisualSpan visualRunData = null)
{
name = name ?? KeyInputSet.NewOneKeyInput(KeyInputUtil.CharToKeyInput('c'));
var flagsRaw = flags ?? CommandFlags.None;
var countRaw = count.HasValue ? FSharpOption.Create(count.Value) : FSharpOption<int>.None;
var funcRaw = func.ToFSharpFunc();
var cmd = Command.NewSimpleCommand(
name,
flagsRaw,
func.ToFSharpFunc());
return new CommandRunData(
cmd,
new Register('c'),
countRaw,
motionRunData != null ? FSharpOption.Create(motionRunData) : FSharpOption<MotionRunData>.None,
visualRunData != null ? FSharpOption.Create(visualRunData) : FSharpOption<VisualSpan>.None);
}
private FSharpFunc<Unit, ITagger<TextMarkerTag>> CreateFunc(Func<ITagger<TextMarkerTag>> func)
{
return func.ToFSharpFunc();
}
internal static Command CreateVisualCommand(
string name = "c",
CommandFlags? flags = null,
VisualKind kind = null,
Func<FSharpOption<int>, Register, VisualSpan, CommandResult> func = null)
{
var flagsArg = flags ?? CommandFlags.None;
kind = kind ?? VisualKind.Line;
if (func == null)
{
func = (x, y, z) => CommandResult.NewCompleted(ModeSwitch.NoSwitch);
}
return Command.NewVisualCommand(
KeyNotationUtil.StringToKeyInputSet(name),
flagsArg,
kind,
func.ToFSharpFunc());
}
public static BindResult <TResult> Convert <T, TResult>(this BindResult <T> res, Func <T, TResult> func)
{
var func2 = func.ToFSharpFunc();
return(res.Convert(func2));
}
private FSharpFunc <Unit, ITagger <TextMarkerTag> > CreateFunc(Func <ITagger <TextMarkerTag> > func)
{
return(func.ToFSharpFunc());
}
private CountedTagger<TextMarkerTag> Create(object key, PropertyCollection propertyCollection, Func<ITagger<TextMarkerTag>> func)
{
return Create(key, propertyCollection, func.ToFSharpFunc());
}
public FSharpAsync <FSharpOption <AudioPlayer.AudioPlayerInfo> > GetCurrentState()
{
Func <FSharpAsyncReplyChannel <AudioPlayer.AudioPlayerInfo>, AudioPlayer.AudioPlayerCommand> func = (x) => AudioPlayer.AudioPlayerCommand.NewGetCurrentState(x);
var result = StateMailbox.PostAndTryAsyncReply <AudioPlayer.AudioPlayerInfo>(func.ToFSharpFunc(), 2000);
return(result);
}
internal static BindData <T> CreateBindData <T>(Func <KeyInput, BindResult <T> > func = null, KeyRemapMode remapMode = null)
{
func = func ?? (x => BindResult <T> .Cancelled);
return(new BindData <T>(FSharpOption.CreateForReference(remapMode), func.ToFSharpFunc()));
}
/// <summary>
/// Returns true if all elements in the CloudFlow satisfy the supplied predicate.
/// </summary>
/// <typeparam name="TSource">Cloud flow element type.</typeparam>
/// <param name="flow">Input cloud flow.</param>
/// <param name="predicate">A function to test each source element for a condition.</param>
/// <returns>Returns true if all elements in the CloudFlow satisfy the supplied predicate.</returns>
public static Cloud <bool> All <TSource>(this CloudFlow <TSource> flow, Func <TSource, bool> predicate)
{
return(CloudFlowModule.forall(predicate.ToFSharpFunc(), flow));
}
internal static CommandBinding CreateMotionBinding(
string name = "default",
CommandFlags flags = CommandFlags.None,
Func <MotionData, NormalCommand> func = null)
{
func = func ?? NormalCommand.NewYank;
return(CommandBinding.NewMotionBinding(KeyNotationUtil.StringToKeyInputSet(name), flags, func.ToFSharpFunc()));
}
