update FCS to <IP_ADDRESS>

This seems to make some improvement when using the F# compiler solutions. However the memory still grows very, very high (after one round of major reductions presumably due to this change).  hI'll put more details here when I have them : ttps://github.com/fsprojects/VisualFSharpPowerTools/issues/1160

@dungpa it seems to break all GoToDefinitionTests. Any ideas?

@dsyme It seems that https://github.com/fsharp/FSharp.Compiler.Service/pull/442 has changed the output of FSharpType.Format considerably.
@vasily-kirichenko Could you add printfn "Output signature: %s" signature before failwithf at https://github.com/fsprojects/VisualFSharpPowerTools/blob/0fc4314320fb97cdad9249da1bf3fe21eaafb160/tests/FSharpVSPowerTools.Core.Tests/GoToDefinitionTests.fs#L113 to see how results have changed.

------ Test started: Assembly: FSharpVSPowerTools.Core.Tests.dll ------

Output signature: namespace Microsoft.FSharp.Control

open System

/// This static class holds members for creating and manipulating asynchronous computations.
[<Sealed>]
[<CompiledName("FSharpAsync")>]
[<Class>]
type Async =
    /// Creates three functions that can be used to implement the .NET Asynchronous
    /// Programming Model (APM) for a given asynchronous computation.
    static member AsBeginEnd : computation:('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit)
    /// Creates an asynchronous computation that waits for a single invocation of a CLI
    /// event by adding a handler to the event. Once the computation completes or is
    /// cancelled, the handler is removed from the event.
    static member AwaitEvent : event:IEvent<'Del,'T> when 'Del : delegate<'T,unit> and 'Del :> Delegate * ?cancelAction:(unit -> unit) -> Async<'T> when 'Del : delegate<'T, unit> and 'Del :> Delegate
    /// Creates an asynchronous computation that will wait on the IAsyncResult.
    static member AwaitIAsyncResult : iar:IAsyncResult * ?millisecondsTimeout:int -> Async<bool>
    ///
    /// Return an asynchronous computation that will wait for the given task to complete and return
    /// its result.
    ///
    static member AwaitTask : task:Threading.Tasks.Task<'T> -> Async<'T>
    /// Creates an asynchronous computation that will wait on the given WaitHandle.
    static member AwaitWaitHandle : waitHandle:Threading.WaitHandle * ?millisecondsTimeout:int -> Async<bool>
    /// Raises the cancellation condition for the most recent set of asynchronous computations started
    /// without any specific CancellationToken. Replaces the global CancellationTokenSource with a new
    /// global token source for any asynchronous computations created after this point without any
    /// specific CancellationToken.
    static member CancelDefaultToken : unit -> unit
    /// Creates an asynchronous computation that returns the CancellationToken governing the execution
    /// of the computation.
    static member CancellationToken : Async<Threading.CancellationToken>
    /// Creates an asynchronous computation that executes computation.
    /// If this computation completes successfully then return Choice1Of2 with the returned
    /// value. If this computation raises an exception before it completes then return Choice2Of2
    /// with the raised exception.
    static member Catch : computation:Async<'T> -> Async<Choice<'T,exn>>
    /// Gets the default cancellation token for executing asynchronous computations.
    static member DefaultCancellationToken : Threading.CancellationToken
    /// Creates an asynchronous computation in terms of a Begin/End pair of actions in
    /// the style used in CLI APIs. This overlaod should be used if the operation is
    /// qualified by three arguments. For example,
    /// Async.FromBeginEnd(arg1,arg2,arg3,ws.BeginGetWeather,ws.EndGetWeather)
    /// When the computation is run, beginFunc is executed, with
    /// a callback which represents the continuation of the computation.
    /// When the callback is invoked, the overall result is fetched using endFunc.
    static member FromBeginEnd : arg1:'Arg1 * arg2:'Arg2 * arg3:'Arg3 * beginAction:('Arg1 * 'Arg2 * 'Arg3 * AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
    /// Creates an asynchronous computation in terms of a Begin/End pair of actions in
    /// the style used in CLI APIs. For example,
    /// Async.FromBeginEnd(ws.BeginGetWeather,ws.EndGetWeather)
    /// When the computation is run, beginFunc is executed, with
    /// a callback which represents the continuation of the computation.
    /// When the callback is invoked, the overall result is fetched using endFunc.
    static member FromBeginEnd : beginAction:(AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
    /// Creates an asynchronous computation in terms of a Begin/End pair of actions in
    /// the style used in CLI APIs. This overlaod should be used if the operation is
    /// qualified by two arguments. For example,
    /// Async.FromBeginEnd(arg1,arg2,ws.BeginGetWeather,ws.EndGetWeather)
    /// When the computation is run, beginFunc is executed, with
    /// a callback which represents the continuation of the computation.
    /// When the callback is invoked, the overall result is fetched using endFunc.
    static member FromBeginEnd : arg1:'Arg1 * arg2:'Arg2 * beginAction:('Arg1 * 'Arg2 * AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
    /// Creates an asynchronous computation in terms of a Begin/End pair of actions in
    /// the style used in CLI APIs. This overlaod should be used if the operation is
    /// qualified by one argument. For example,
    /// Async.FromBeginEnd(place,ws.BeginGetWeather,ws.EndGetWeather)
    /// When the computation is run, beginFunc is executed, with
    /// a callback which represents the continuation of the computation.
    /// When the callback is invoked, the overall result is fetched using endFunc.
    static member FromBeginEnd : arg:'Arg1 * beginAction:('Arg1 * AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
    /// Creates an asynchronous computation that captures the current
    /// success, exception and cancellation continuations. The callback must
    /// eventually call exactly one of the given continuations.
    static member FromContinuations : callback:(('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T>
    /// Creates an asynchronous computation that runs the given computation and ignores
    /// its result.
    static member Ignore : computation:Async<'T> -> Async<unit>
    /// Generates a scoped, cooperative cancellation handler for use within an asynchronous workflow.
    static member OnCancel : interruption:(unit -> unit) -> Async<IDisposable>
    /// Creates an asynchronous computation that executes all the given asynchronous computations,
    /// initially queueing each as work items and using a fork/join pattern.
    static member Parallel : computations:seq<Async<'T>> -> Async<'T []>
    /// Runs the asynchronous computation and await its result.
    static member RunSynchronously : computation:Async<'T> * ?timeout:int * ?cancellationToken:Threading.CancellationToken -> 'T
    /// Creates an asynchronous computation that will sleep for the given time. This is scheduled
    /// using a System.Threading.Timer object. The operation will not block operating system threads
    /// for the duration of the wait.
    static member Sleep : millisecondsDueTime:int -> Async<unit>
    /// Starts the asynchronous computation in the thread pool. Do not await its result.
    static member Start : computation:Async<unit> * ?cancellationToken:Threading.CancellationToken -> unit
    /// Executes a computation in the thread pool.
    static member StartAsTask : computation:Async<'T> * ?taskCreationOptions:Threading.Tasks.TaskCreationOptions * ?cancellationToken:Threading.CancellationToken -> Threading.Tasks.Task<'T>
    /// Starts a child computation within an asynchronous workflow.
    /// This allows multiple asynchronous computations to be executed simultaneously.
    static member StartChild : computation:Async<'T> * ?millisecondsTimeout:int -> Async<Async<'T>>
    /// Creates an asynchronous computation which starts the given computation as a System.Threading.Tasks.Task
    static member StartChildAsTask : computation:Async<'T> * ?taskCreationOptions:Threading.Tasks.TaskCreationOptions -> Async<Threading.Tasks.Task<'T>>
    /// Runs an asynchronous computation, starting immediately on the current operating system
    /// thread.
    static member StartImmediate : computation:Async<unit> * ?cancellationToken:Threading.CancellationToken -> unit
    /// Runs an asynchronous computation, starting immediately on the current operating system
    /// thread. Call one of the three continuations when the operation completes.
    static member StartWithContinuations : computation:Async<'T> * continuation:('T -> unit) * exceptionContinuation:(exn -> unit) * cancellationContinuation:(OperationCanceledException -> unit) * ?cancellationToken:Threading.CancellationToken -> unit
    /// Creates an asynchronous computation that runs
    /// its continuation using syncContext.Post. If syncContext is null
    /// then the asynchronous computation is equivalent to SwitchToThreadPool().
    static member SwitchToContext : syncContext:Threading.SynchronizationContext -> Async<unit>
    /// Creates an asynchronous computation that creates a new thread and runs
    /// its continuation in that thread.
    static member SwitchToNewThread : unit -> Async<unit>
    /// Creates an asynchronous computation that queues a work item that runs
    /// its continuation.
    static member SwitchToThreadPool : unit -> Async<unit>
    /// Creates an asynchronous computation that executes computation.
    /// If this computation is cancelled before it completes then the computation generated by
    /// running compensation is executed.
    static member TryCancelled : computation:Async<'T> * compensation:(OperationCanceledException -> unit) -> Async<'T>

Test 'FSharpVSPowerTools.Core.Tests.GoToDefinitionTests.adds necessary parenthesis to function parameters' failed: System.Exception : Type checking results in errors: [|C:\Temp.fsi (16,107)-(16,108) parse error Unexpected symbol '?' in type|]
	D:\git\VisualFSharpPowerTools\tests\FSharpVSPowerTools.Core.Tests\GoToDefinitionTests.fs(115,0): at FSharpVSPowerTools.Core.Tests.GoToDefinitionTests.generateDefinitionFromPos@115.Invoke(String message)
	D:\git\VisualFSharpPowerTools\tests\FSharpVSPowerTools.Core.Tests\GoToDefinitionTests.fs(116,0): at FSharpVSPowerTools.Core.Tests.GoToDefinitionTests.generateDefinitionFromPos(pos caretPos, String src)
	D:\git\VisualFSharpPowerTools\tests\FSharpVSPowerTools.Core.Tests\GoToDefinitionTests.fs(158,0): at FSharpVSPowerTools.Core.Tests.GoToDefinitionTests.adds necessary parenthesis to function parameters()

Output signature: module File

type MyClass< ^T when ^T : (static member ``A static member`` : unit ->  ^T when  ^T : (static member ( A static member ) : ->  ^T))> =
    class
    end

Test 'FSharpVSPowerTools.Core.Tests.GoToDefinitionTests.handle double-backtick identifiers on member constraints' failed:
	System.Exception : Type checking results in errors: [|C:\Temp.fsi (3,105)-(3,106) parse error Unexpected identifier in member signature;
  C:\Temp.fsi (3,103)-(3,122) parse error Attempted to parse this as an operator name, but failed;
  C:\Temp.fsi (3,125)-(3,127) parse error Unexpected symbol '->' in member signature;
  C:\Temp.fsi (5,5)-(5,8) parse error Unexpected keyword 'end' in signature file|]
	D:\git\VisualFSharpPowerTools\tests\FSharpVSPowerTools.Core.Tests\GoToDefinitionTests.fs(115,0): at FSharpVSPowerTools.Core.Tests.GoToDefinitionTests.generateDefinitionFromPos@115.Invoke(String message)
	D:\git\VisualFSharpPowerTools\tests\FSharpVSPowerTools.Core.Tests\GoToDefinitionTests.fs(116,0): at FSharpVSPowerTools.Core.Tests.GoToDefinitionTests.generateDefinitionFromPos(pos caretPos, String src)
	at Microsoft.FSharp.Primitives.Basics.List.map[T,TResult](FSharpFunc`2 mapping, FSharpList`1 x)
	D:\git\VisualFSharpPowerTools\tests\FSharpVSPowerTools.Core.Tests\GoToDefinitionTests.fs(1395,0): at FSharpVSPowerTools.Core.Tests.GoToDefinitionTests.handle double-backtick identifiers on member constraints()

Output signature: module File

type MyClass<'T when 'T : struct> =
    new : unit -> MyClass<'T>
    member Method : x:'X when 'X : null -> int when 'X : null
    member NormalMethod : unit -> unit
    static member StaticMethod : x:('X * 'X when 'X : equality) -> bool when 'X : equality

Test 'FSharpVSPowerTools.Core.Tests.GoToDefinitionTests.handle generic constraints on methods' failed: System.Exception : Type checking results in errors: [|C:\Temp.fsi (5,41)-(5,43) parse error Unexpected symbol '->' in type signature. Expected incomplete structured construct at or before this point or other token.;
  C:\Temp.fsi (8,1)-(8,1) parse error Incomplete structured construct at or before this point in signature file;
  C:\Temp.fsi (5,31)-(5,33) typecheck error The type parameter 'X' is not defined|]
	D:\git\VisualFSharpPowerTools\tests\FSharpVSPowerTools.Core.Tests\GoToDefinitionTests.fs(115,0): at FSharpVSPowerTools.Core.Tests.GoToDefinitionTests.generateDefinitionFromPos@115.Invoke(String message)
	D:\git\VisualFSharpPowerTools\tests\FSharpVSPowerTools.Core.Tests\GoToDefinitionTests.fs(116,0): at FSharpVSPowerTools.Core.Tests.GoToDefinitionTests.generateDefinitionFromPos(pos caretPos, String src)
	D:\git\VisualFSharpPowerTools\tests\FSharpVSPowerTools.Core.Tests\GoToDefinitionTests.fs(1222,0): at FSharpVSPowerTools.Core.Tests.GoToDefinitionTests.handle generic constraints on methods()

Output signature: module File

val func : x:'X when 'X : null and 'X : comparison -> int when 'X : null and 'X : comparison

Test 'FSharpVSPowerTools.Core.Tests.GoToDefinitionTests.handle generic constraints on module functions and values' failed:
	System.Exception : Type checking results in errors: [|C:\Temp.fsi (3,52)-(3,54) parse error Unexpected symbol '->'. Expected incomplete structured construct at or before this point or other token.;
  C:\Temp.fsi (3,5)-(3,9) typecheck error Return values cannot have names|]
	D:\git\VisualFSharpPowerTools\tests\FSharpVSPowerTools.Core.Tests\GoToDefinitionTests.fs(115,0): at FSharpVSPowerTools.Core.Tests.GoToDefinitionTests.generateDefinitionFromPos@115.Invoke(String message)
	D:\git\VisualFSharpPowerTools\tests\FSharpVSPowerTools.Core.Tests\GoToDefinitionTests.fs(116,0): at FSharpVSPowerTools.Core.Tests.GoToDefinitionTests.generateDefinitionFromPos(pos caretPos, String src)
	at Microsoft.FSharp.Primitives.Basics.List.map[T,TResult](FSharpFunc`2 mapping, FSharpList`1 x)
	D:\git\VisualFSharpPowerTools\tests\FSharpVSPowerTools.Core.Tests\GoToDefinitionTests.fs(1233,0): at FSharpVSPowerTools.Core.Tests.GoToDefinitionTests.handle generic constraints on module functions and values()

Output signature: /// Basic operations on arrays.
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
[<RequireQualifiedAccess>]
module Microsoft.FSharp.Collections.Array

/// Builds a new array that contains the elements of the first array followed by the elements of the second array.
val append : array1:'T [] -> array2:'T [] -> 'T []
/// Returns the average of the elements in the array.
val inline average : array: ^T [] when  ^T : (static member ( + ) :  ^T *  ^T ->  ^T) and  ^T : (static member DivideByInt :  ^T * int ->  ^T) and  ^T : (static member get_Zero : ->  ^T) ->  ^T when  ^T : (static member ( + ) :  ^T *  ^T ->  ^T) and  ^T : (static member DivideByInt :  ^T * int ->  ^T) and  ^T : (static member get_Zero : ->  ^T) when ^T : (static member ( + ) :  ^T when  ^T : (static member ( + ) :  ^T *  ^T ->  ^T) and  ^T : (static member DivideByInt :  ^T * int ->  ^T) and  ^T : (static member get_Zero : ->  ^T) *  ^T when  ^T : (static member ( + ) :  ^T *  ^T ->  ^T) and  ^T : (static member DivideByInt :  ^T * int ->  ^T) and  ^T : (static member get_Zero : ->  ^T) ->  ^T when  ^T : (static member ( + ) :  ^T *  ^T ->  ^T) and  ^T : (static member DivideByInt :  ^T * int ->  ^T) and  ^T : (static member get_Zero : ->  ^T)) and ^T : (static member DivideByInt :  ^T when  ^T : (static member ( + ) :  ^T *  ^T ->  ^T) and  ^T : (static member DivideByInt :  ^T * int ->  ^T) and  ^T : (static member get_Zero : ->  ^T) * int ->  ^T when  ^T : (static member ( + ) :  ^T *  ^T ->  ^T) and  ^T : (static member DivideByInt :  ^T * int ->  ^T) and  ^T : (static member get_Zero : ->  ^T)) and ^T : (static member Zero :  ^T when  ^T : (static member ( + ) :  ^T *  ^T ->  ^T) and  ^T : (static member DivideByInt :  ^T * int ->  ^T) and  ^T : (static member get_Zero : ->  ^T))
/// Returns the average of the elements generated by applying the function to each element of the array.
val inline averageBy : projection:('T ->  ^U when  ^U : (static member ( + ) :  ^U *  ^U ->  ^U) and  ^U : (static member DivideByInt :  ^U * int ->  ^U) and  ^U : (static member get_Zero : ->  ^U)) -> array:'T [] ->  ^U when  ^U : (static member ( + ) :  ^U *  ^U ->  ^U) and  ^U : (static member DivideByInt :  ^U * int ->  ^U) and  ^U : (static member get_Zero : ->  ^U) when ^U : (static member ( + ) :  ^U when  ^U : (static member ( + ) :  ^U *  ^U ->  ^U) and  ^U : (static member DivideByInt :  ^U * int ->  ^U) and  ^U : (static member get_Zero : ->  ^U) *  ^U when  ^U : (static member ( + ) :  ^U *  ^U ->  ^U) and  ^U : (static member DivideByInt :  ^U * int ->  ^U) and  ^U : (static member get_Zero : ->  ^U) ->  ^U when  ^U : (static member ( + ) :  ^U *  ^U ->  ^U) and  ^U : (static member DivideByInt :  ^U * int ->  ^U) and  ^U : (static member get_Zero : ->  ^U)) and ^U : (static member DivideByInt :  ^U when  ^U : (static member ( + ) :  ^U *  ^U ->  ^U) and  ^U : (static member DivideByInt :  ^U * int ->  ^U) and  ^U : (static member get_Zero : ->  ^U) * int ->  ^U when  ^U : (static member ( + ) :  ^U *  ^U ->  ^U) and  ^U : (static member DivideByInt :  ^U * int ->  ^U) and  ^U : (static member get_Zero : ->  ^U)) and ^U : (static member Zero :  ^U when  ^U : (static member ( + ) :  ^U *  ^U ->  ^U) and  ^U : (static member DivideByInt :  ^U * int ->  ^U) and  ^U : (static member get_Zero : ->  ^U))
/// Reads a range of elements from the first array and write them into the second.
val blit : source:'T [] -> sourceIndex:int -> target:'T [] -> targetIndex:int -> count:int -> unit
/// For each element of the array, applies the given function. Concatenates all the results and return the combined array.
val collect : mapping:('T -> 'U []) -> array:'T [] -> 'U []
/// Builds a new array that contains the elements of each of the given sequence of arrays.
val concat : arrays:seq<'T []> -> 'T []
/// Builds a new array that contains the elements of the given array.
val copy : array:'T [] -> 'T []
/// Creates an array whose elements are all initially the given value.
val create : count:int -> value:'T -> 'T []
/// Applies the given function to successive elements, returning the first
/// result where function returns Some(x) for some x. If the function
/// never returns Some(x) then None is returned.
val tryPick : chooser:('T -> 'U option) -> array:'T [] -> 'U option
/// Fills a range of elements of the array with the given value.
val fill : target:'T [] -> targetIndex:int -> count:int -> value:'T -> unit
/// Applies the given function to successive elements, returning the first
/// result where function returns Some(x) for some x. If the function
/// never returns Some(x) then KeyNotFoundException is raised.
val pick : chooser:('T -> 'U option) -> array:'T [] -> 'U
/// Applies the given function to each element of the array. Returns
/// the array comprised of the results "x" for each element where
/// the function returns Some(x)
val choose : chooser:('T -> 'U option) -> array:'T [] -> 'U []
/// Returns an empty array of the given type.
val empty : 'T []
/// Tests if any element of the array satisfies the given predicate.
val exists : predicate:('T -> bool) -> array:'T [] -> bool
/// Tests if any pair of corresponding elements of the arrays satisfies the given predicate.
val exists2 : predicate:('T1 -> 'T2 -> bool) -> array1:'T1 [] -> array2:'T2 [] -> bool
/// Returns a new collection containing only the elements of the collection
/// for which the given predicate returns "true".
val filter : predicate:('T -> bool) -> array:'T [] -> 'T []
/// Returns the first element for which the given function returns 'true'.
/// Raise KeyNotFoundException if no such element exists.
val find : predicate:('T -> bool) -> array:'T [] -> 'T
/// Returns the index of the first element in the array
/// that satisfies the given predicate. Raise KeyNotFoundException if
/// none of the elements satisy the predicate.
val findIndex : predicate:('T -> bool) -> array:'T [] -> int
/// Tests if all elements of the array satisfy the given predicate.
val forall : predicate:('T -> bool) -> array:'T [] -> bool
/// Tests if all corresponding elements of the array satisfy the given predicate pairwise.
val forall2 : predicate:('T1 -> 'T2 -> bool) -> array1:'T1 [] -> array2:'T2 [] -> bool
/// Applies a function to each element of the collection, threading an accumulator argument
/// through the computation. If the input function is f and the elements are i0...iN then computes
/// f (... (f s i0)...) iN
val fold : folder:('State -> 'T -> 'State) -> state:'State -> array:'T [] -> 'State
/// Applies a function to each element of the array, threading an accumulator argument
/// through the computation. If the input function is f and the elements are i0...iN then computes
/// f i0 (...(f iN s))
val foldBack : folder:('T -> 'State -> 'State) -> array:'T [] -> state:'State -> 'State
/// Applies a function to pairs of elements drawn from the two collections,
/// left-to-right, threading an accumulator argument
/// through the computation. The two input
/// arrays must have the same lengths, otherwise an ArgumentException is
/// raised.
val fold2 : folder:('State -> 'T1 -> 'T2 -> 'State) -> state:'State -> array1:'T1 [] -> array2:'T2 [] -> 'State
/// Apply a function to pairs of elements drawn from the two collections, right-to-left,
/// threading an accumulator argument through the computation. The two input
/// arrays must have the same lengths, otherwise an ArgumentException is
/// raised.
val foldBack2 : folder:('T1 -> 'T2 -> 'State -> 'State) -> array1:'T1 [] -> array2:'T2 [] -> state:'State -> 'State
/// Gets an element from an array.
val get : array:'T [] -> index:int -> 'T
/// Creates an array given the dimension and a generator function to compute the elements.
val inline init : count:int -> initializer:(int -> 'T) -> 'T []
/// Creates an array where the entries are initially the default value Unchecked.defaultof<'T>.
val zeroCreate : count:int -> 'T []
/// Returns true if the given array is empty, otherwise false.
val isEmpty : array:'T [] -> bool
/// Applies the given function to each element of the array.
val inline iter : action:('T -> unit) -> array:'T [] -> unit
/// Applies the given function to pair of elements drawn from matching indices in two arrays. The
/// two arrays must have the same lengths, otherwise an ArgumentException is
/// raised.
val iter2 : action:('T1 -> 'T2 -> unit) -> array1:'T1 [] -> array2:'T2 [] -> unit
/// Applies the given function to each element of the array. The integer passed to the
/// function indicates the index of element.
val iteri : action:(int -> 'T -> unit) -> array:'T [] -> unit
/// Applies the given function to pair of elements drawn from matching indices in two arrays,
/// also passing the index of the elements. The two arrays must have the same lengths,
/// otherwise an ArgumentException is raised.
val iteri2 : action:(int -> 'T1 -> 'T2 -> unit) -> array1:'T1 [] -> array2:'T2 [] -> unit
/// Returns the length of an array. You can also use property arr.Length.
val length : array:'T [] -> int
/// Builds a new array whose elements are the results of applying the given function
/// to each of the elements of the array.
val inline map : mapping:('T -> 'U) -> array:'T [] -> 'U []
/// Builds a new collection whose elements are the results of applying the given function
/// to the corresponding elements of the two collections pairwise. The two input
/// arrays must have the same lengths, otherwise an ArgumentException is
/// raised.
val map2 : mapping:('T1 -> 'T2 -> 'U) -> array1:'T1 [] -> array2:'T2 [] -> 'U []
/// Builds a new collection whose elements are the results of applying the given function
/// to the corresponding elements of the two collections pairwise, also passing the index of
/// the elements. The two input arrays must have the same lengths, otherwise an ArgumentException is
/// raised.
val mapi2 : mapping:(int -> 'T1 -> 'T2 -> 'U) -> array1:'T1 [] -> array2:'T2 [] -> 'U []
/// Builds a new array whose elements are the results of applying the given function
/// to each of the elements of the array. The integer index passed to the
/// function indicates the index of element being transformed.
val mapi : mapping:(int -> 'T -> 'U) -> array:'T [] -> 'U []
/// Returns the greatest of all elements of the array, compared via Operators.max on the function result.
val inline max : array:'T [] when 'T : comparison -> 'T when 'T : comparison when 'T : comparison
/// Returns the greatest of all elements of the array, compared via Operators.max on the function result.
val inline maxBy : projection:('T -> 'U when 'U : comparison) -> array:'T [] -> 'T when 'U : comparison
/// Returns the lowest of all elements of the array, compared via Operators.min.
val inline min : array:'T [] when 'T : comparison -> 'T when 'T : comparison when 'T : comparison
/// Returns the lowest of all elements of the array, compared via Operators.min on the function result.
val inline minBy : projection:('T -> 'U when 'U : comparison) -> array:'T [] -> 'T when 'U : comparison
/// Builds an array from the given list.
val ofList : list:'T list -> 'T []
/// Builds a new array from the given enumerable object.
val ofSeq : source:seq<'T> -> 'T []
/// Splits the collection into two collections, containing the
/// elements for which the given predicate returns "true" and "false"
/// respectively.
val partition : predicate:('T -> bool) -> array:'T [] -> 'T [] * 'T []
/// Returns an array with all elements permuted according to the
/// specified permutation.
val permute : indexMap:(int -> int) -> array:'T [] -> 'T []
/// Applies a function to each element of the array, threading an accumulator argument
/// through the computation. If the input function is f and the elements are i0...iN
/// then computes f (... (f i0 i1)...) iN.
/// Raises ArgumentException if the array has size zero.
val reduce : reduction:('T -> 'T -> 'T) -> array:'T [] -> 'T
/// Applies a function to each element of the array, threading an accumulator argument
/// through the computation. If the input function is f and the elements are i0...iN
/// then computes f i0 (...(f iN-1 iN)).
/// Raises ArgumentException if the array has size zero.
val reduceBack : reduction:('T -> 'T -> 'T) -> array:'T [] -> 'T
/// Returns a new array with the elements in reverse order.
val rev : array:'T [] -> 'T []
/// Like fold, but return the intermediary and final results.
val scan : folder:('State -> 'T -> 'State) -> state:'State -> array:'T [] -> 'State []
/// Like foldBack, but return both the intermediary and final results.
val scanBack : folder:('T -> 'State -> 'State) -> array:'T [] -> state:'State -> 'State []
/// Sets an element of an array.
val set : array:'T [] -> index:int -> value:'T -> unit
/// Builds a new array that contains the given subrange specified by
/// starting index and length.
val sub : array:'T [] -> startIndex:int -> count:int -> 'T []
/// Sorts the elements of an array, returning a new array. Elements are compared using Operators.compare.
val sort : array:'T [] when 'T : comparison -> 'T [] when 'T : comparison when 'T : comparison
/// Sorts the elements of an array, using the given projection for the keys and returning a new array.
/// Elements are compared using Operators.compare.
val sortBy : projection:('T -> 'Key when 'Key : comparison) -> array:'T [] -> 'T [] when 'Key : comparison
/// Sorts the elements of an array, using the given comparison function as the order, returning a new array.
val sortWith : comparer:('T -> 'T -> int) -> array:'T [] -> 'T []
/// Sorts the elements of an array by mutating the array in-place, using the given projection for the keys.
/// Elements are compared using Operators.compare.
val sortInPlaceBy : projection:('T -> 'Key when 'Key : comparison) -> array:'T [] -> unit when 'Key : comparison
/// Sorts the elements of an array by mutating the array in-place, using the given comparison function as the order.
val sortInPlaceWith : comparer:('T -> 'T -> int) -> array:'T [] -> unit
/// Sorts the elements of an array by mutating the array in-place, using the given comparison function.
/// Elements are compared using Operators.compare.
val sortInPlace : array:'T [] when 'T : comparison -> unit when 'T : comparison
/// Returns the sum of the elements in the array.
val inline sum : array: ^T [] when  ^T : (static member ( + ) :  ^T *  ^T ->  ^T) and  ^T : (static member get_Zero : ->  ^T) ->  ^T when  ^T : (static member ( + ) :  ^T *  ^T ->  ^T) and  ^T : (static member get_Zero : ->  ^T) when ^T : (static member ( + ) :  ^T when  ^T : (static member ( + ) :  ^T *  ^T ->  ^T) and  ^T : (static member get_Zero : ->  ^T) *  ^T when  ^T : (static member ( + ) :  ^T *  ^T ->  ^T) and  ^T : (static member get_Zero : ->  ^T) ->  ^T when  ^T : (static member ( + ) :  ^T *  ^T ->  ^T) and  ^T : (static member get_Zero : ->  ^T)) and ^T : (static member Zero :  ^T when  ^T : (static member ( + ) :  ^T *  ^T ->  ^T) and  ^T : (static member get_Zero : ->  ^T))
/// Returns the sum of the results generated by applying the function to each element of the array.
val inline sumBy : projection:('T ->  ^U when  ^U : (static member ( + ) :  ^U *  ^U ->  ^U) and  ^U : (static member get_Zero : ->  ^U)) -> array:'T [] ->  ^U when  ^U : (static member ( + ) :  ^U *  ^U ->  ^U) and  ^U : (static member get_Zero : ->  ^U) when ^U : (static member ( + ) :  ^U when  ^U : (static member ( + ) :  ^U *  ^U ->  ^U) and  ^U : (static member get_Zero : ->  ^U) *  ^U when  ^U : (static member ( + ) :  ^U *  ^U ->  ^U) and  ^U : (static member get_Zero : ->  ^U) ->  ^U when  ^U : (static member ( + ) :  ^U *  ^U ->  ^U) and  ^U : (static member get_Zero : ->  ^U)) and ^U : (static member Zero :  ^U when  ^U : (static member ( + ) :  ^U *  ^U ->  ^U) and  ^U : (static member get_Zero : ->  ^U))
/// Builds a list from the given array.
val toList : array:'T [] -> 'T list
/// Views the given array as a sequence.
val toSeq : array:'T [] -> seq<'T>
/// Returns the first element for which the given function returns true.
/// Return None if no such element exists.
val tryFind : predicate:('T -> bool) -> array:'T [] -> 'T option
/// Returns the index of the first element in the array
/// that satisfies the given predicate.
val tryFindIndex : predicate:('T -> bool) -> array:'T [] -> int option
/// Splits an array of pairs into two arrays.
val unzip : array:('T1 * 'T2) [] -> 'T1 [] * 'T2 []
/// Splits an array of triples into three arrays.
val unzip3 : array:('T1 * 'T2 * 'T3) [] -> 'T1 [] * 'T2 [] * 'T3 []
/// Combines the two arrays into an array of pairs. The two arrays must have equal lengths, otherwise an ArgumentException is
/// raised.
val zip : array1:'T1 [] -> array2:'T2 [] -> ('T1 * 'T2) []
/// Combines three arrays into an array of pairs. The three arrays must have equal lengths, otherwise an ArgumentException is
/// raised.
val zip3 : array1:'T1 [] -> array2:'T2 [] -> array3:'T3 [] -> ('T1 * 'T2 * 'T3) []

/// Provides parallel operations on arrays
module Parallel =

    /// Apply the given function to each element of the array. Return
    /// the array comprised of the results "x" for each element where
    /// the function returns Some(x).
    val choose : chooser:('T -> 'U option) -> array:'T [] -> 'U []
    /// For each element of the array, apply the given function. Concatenate all the results and return the combined array.
    val collect : mapping:('T -> 'U []) -> array:'T [] -> 'U []
    /// Build a new array whose elements are the results of applying the given function
    /// to each of the elements of the array.
    val map : mapping:('T -> 'U) -> array:'T [] -> 'U []
    /// Build a new array whose elements are the results of applying the given function
    /// to each of the elements of the array. The integer index passed to the
    /// function indicates the index of element being transformed.
    val mapi : mapping:(int -> 'T -> 'U) -> array:'T [] -> 'U []
    /// Apply the given function to each element of the array.
    val iter : action:('T -> unit) -> array:'T [] -> unit
    /// Apply the given function to each element of the array. The integer passed to the
    /// function indicates the index of element.
    val iteri : action:(int -> 'T -> unit) -> array:'T [] -> unit
    /// Create an array given the dimension and a generator function to compute the elements.
    val init : count:int -> initializer:(int -> 'T) -> 'T []
    /// Split the collection into two collections, containing the
    /// elements for which the given predicate returns "true" and "false"
    /// respectively
    val partition : predicate:('T -> bool) -> array:'T [] -> 'T [] * 'T []

Test 'FSharpVSPowerTools.Core.Tests.GoToDefinitionTests.handle nested modules' failed: System.Exception : Type checking results in errors: [|C:\Temp.fsi (9,180)-(9,182) parse error Unexpected symbol '->' in member signature;
  C:\Temp.fsi (11,46)-(11,50) parse error Unexpected keyword 'when' in value signature. Expected ',' or other token.;
  C:\Temp.fsi (11,78)-(11,79) parse error Unexpected symbol ':'. Expected incomplete structured construct at or before this point or other token.;
  C:\Temp.fsi (11,12)-(11,21) typecheck error Return values cannot have names|]
	D:\git\VisualFSharpPowerTools\tests\FSharpVSPowerTools.Core.Tests\GoToDefinitionTests.fs(115,0): at FSharpVSPowerTools.Core.Tests.GoToDefinitionTests.generateDefinitionFromPos@115.Invoke(String message)
	D:\git\VisualFSharpPowerTools\tests\FSharpVSPowerTools.Core.Tests\GoToDefinitionTests.fs(116,0): at FSharpVSPowerTools.Core.Tests.GoToDefinitionTests.generateDefinitionFromPos(pos caretPos, String src)
	D:\git\VisualFSharpPowerTools\tests\FSharpVSPowerTools.Core.Tests\GoToDefinitionTests.fs(767,0): at FSharpVSPowerTools.Core.Tests.GoToDefinitionTests.handle nested modules()

Output signature: module File

type MyClass< ^T when ^T : (static member Create : unit ->  ^T when  ^T : (static member Create : ->  ^T) and  ^T : (member get_Prop :  ^T -> int)) and ^T : (member Prop : int)> =
    class
    end

Test 'FSharpVSPowerTools.Core.Tests.GoToDefinitionTests.handle statically resolved constraints' failed: System.Exception : Type checking results in errors: [|C:\Temp.fsi (3,99)-(3,101) parse error Unexpected symbol '->' in member signature;
  C:\Temp.fsi (5,5)-(5,8) parse error Unexpected keyword 'end' in signature file|]
	D:\git\VisualFSharpPowerTools\tests\FSharpVSPowerTools.Core.Tests\GoToDefinitionTests.fs(115,0): at FSharpVSPowerTools.Core.Tests.GoToDefinitionTests.generateDefinitionFromPos@115.Invoke(String message)
	D:\git\VisualFSharpPowerTools\tests\FSharpVSPowerTools.Core.Tests\GoToDefinitionTests.fs(116,0): at FSharpVSPowerTools.Core.Tests.GoToDefinitionTests.generateDefinitionFromPos(pos caretPos, String src)
	at Microsoft.FSharp.Primitives.Basics.List.map[T,TResult](FSharpFunc`2 mapping, FSharpList`1 x)
	D:\git\VisualFSharpPowerTools\tests\FSharpVSPowerTools.Core.Tests\GoToDefinitionTests.fs(1338,0): at FSharpVSPowerTools.Core.Tests.GoToDefinitionTests.handle statically resolved constraints()

Output signature: [<AutoOpen>]
module Microsoft.FSharp.Core.ExtraTopLevelOperators

/// Print to stdout using the given format.
val printf : format:Printf.TextWriterFormat<'T> -> 'T
/// Print to stdout using the given format, and add a newline.
val printfn : format:Printf.TextWriterFormat<'T> -> 'T
/// Print to stderr using the given format.
val eprintf : format:Printf.TextWriterFormat<'T> -> 'T
/// Print to stderr using the given format, and add a newline.
val eprintfn : format:Printf.TextWriterFormat<'T> -> 'T
/// Print to a string using the given format.
val sprintf : format:Printf.StringFormat<'T> -> 'T
/// Print to a string buffer and raise an exception with the given
/// result.   Helper printers must return strings.
val failwithf : format:Printf.StringFormat<'T,'Result> -> 'T
/// Print to a file using the given format.
val fprintf : textWriter:System.IO.TextWriter -> format:Printf.TextWriterFormat<'T> -> 'T
/// Print to a file using the given format, and add a newline.
val fprintfn : textWriter:System.IO.TextWriter -> format:Printf.TextWriterFormat<'T> -> 'T
/// Builds a set from a sequence of objects. The objects are indexed using generic comparison.
val set : elements:seq<'T> when 'T : comparison -> Set<'T> when 'T : comparison when 'T : comparison
/// Builds an aysnchronous workflow using computation expression syntax.
val async : AsyncBuilder
/// Converts the argument to 32-bit float.
val inline single : value: ^T when  ^T : (static member op_Explicit :  ^T -> single) -> single when ^T : (static member op_Explicit : unit -> single)
/// Converts the argument to 64-bit float.
val inline double : value: ^T when  ^T : (static member op_Explicit :  ^T -> double) -> float when ^T : (static member op_Explicit : unit -> double)
/// Converts the argument to byte.
val inline uint8 : value: ^T when  ^T : (static member op_Explicit :  ^T -> byte) -> byte when ^T : (static member op_Explicit : unit -> byte)
/// Converts the argument to signed byte.
val inline int8 : value: ^T when  ^T : (static member op_Explicit :  ^T -> sbyte) -> sbyte when ^T : (static member op_Explicit : unit -> sbyte)
/// Builds a read-only lookup table from a sequence of key/value pairs. The key objects are indexed using generic hashing and equality.
val dict : keyValuePairs:seq<'Key * 'Value> when 'Key : equality -> System.Collections.Generic.IDictionary<'Key,'Value> when 'Key : equality when 'Key : equality
/// Builds a 2D array from a sequence of sequences of elements.
val array2D : rows:seq<#seq<'T>> -> 'T [,] when 'c :> seq<'T>
/// Special prefix operator for splicing typed expressions into quotation holes.
val ( ~% ) : expression:Quotations.Expr<'T> -> 'T
/// Special prefix operator for splicing untyped expressions into quotation holes.
val ( ~%% ) : expression:Quotations.Expr -> 'T
/// An active pattern to force the execution of values of type Lazy<_>.
val (|Lazy|) : input:Lazy<'T> -> 'T
/// Builds a query using query syntax and operators.
val query : Linq.QueryBuilder

Test 'FSharpVSPowerTools.Core.Tests.GoToDefinitionTests.handle uninstantiated type parameters' failed: System.Exception : Type checking results in errors: [|C:\Temp.fsi (22,49)-(22,51) parse error Unexpected symbol '->'. Expected incomplete structured construct at or before this point or other token.;
  C:\Temp.fsi (22,5)-(22,8) typecheck error Return values cannot have names|]
	D:\git\VisualFSharpPowerTools\tests\FSharpVSPowerTools.Core.Tests\GoToDefinitionTests.fs(115,0): at FSharpVSPowerTools.Core.Tests.GoToDefinitionTests.generateDefinitionFromPos@115.Invoke(String message)
	D:\git\VisualFSharpPowerTools\tests\FSharpVSPowerTools.Core.Tests\GoToDefinitionTests.fs(116,0): at FSharpVSPowerTools.Core.Tests.GoToDefinitionTests.generateDefinitionFromPos(pos caretPos, String src)
	D:\git\VisualFSharpPowerTools\tests\FSharpVSPowerTools.Core.Tests\GoToDefinitionTests.fs(1492,0): at FSharpVSPowerTools.Core.Tests.GoToDefinitionTests.handle uninstantiated type parameters()

Output signature: module File

val inline func : x: ^a when  ^a : (static member ( + ) :  ^a *  ^a ->  ^b) ->  ^b when  ^a : (static member ( + ) :  ^a *  ^a ->  ^b) when ^a : (static member ( + ) :  ^a when  ^a : (static member ( + ) :  ^a *  ^a ->  ^b) *  ^a when  ^a : (static member ( + ) :  ^a *  ^a ->  ^b) ->  ^b when  ^a : (static member ( + ) :  ^a *  ^a ->  ^b))

Test 'FSharpVSPowerTools.Core.Tests.GoToDefinitionTests.operator names are demangled' failed: System.Exception : Type checking results in errors: [|C:\Temp.fsi (3,77)-(3,79) parse error Unexpected symbol '->'. Expected incomplete structured construct at or before this point or other token.;
  C:\Temp.fsi (3,12)-(3,16) typecheck error Return values cannot have names|]
	D:\git\VisualFSharpPowerTools\tests\FSharpVSPowerTools.Core.Tests\GoToDefinitionTests.fs(115,0): at FSharpVSPowerTools.Core.Tests.GoToDefinitionTests.generateDefinitionFromPos@115.Invoke(String message)
	D:\git\VisualFSharpPowerTools\tests\FSharpVSPowerTools.Core.Tests\GoToDefinitionTests.fs(116,0): at FSharpVSPowerTools.Core.Tests.GoToDefinitionTests.generateDefinitionFromPos(pos caretPos, String src)
	D:\git\VisualFSharpPowerTools\tests\FSharpVSPowerTools.Core.Tests\GoToDefinitionTests.fs(1254,0): at FSharpVSPowerTools.Core.Tests.GoToDefinitionTests.operator names are demangled()

49 passed, 8 failed, 0 skipped, took 13,29 seconds (NUnit 2.6.4).

Committed.

@dsyme We generated fsi files using FSharpType.Format function. Now the function also prints member constraints that the compiler doesn't accept inside signature files. Is there any way for us to preserve the old behaviour? Thanks.

On it

https://github.com/fsharp/FSharp.Compiler.Service/pull/444/

Note this disables the max-memory trigger by default though it can be set on by an environment variable https://github.com/fsharp/FSharp.Compiler.Service/pull/444/files#diff-d3c6e872b60cb8a91665cdd9d5e5ca27R65

https://www.nuget.org/packages/FSharp.Compiler.Service/<IP_ADDRESS>

It sounds like a case of memory leaks to me. It would be great if we can get a snapshot of VS memory usage and investigate further.

Perhaps - it's only in these large-project scenarios that things seem to leak though, which seems odd.  There are other kinds of leaks that can happen such as an ever-increasing number of requests in the FCS request queue.   I'm in the process of instrumenting FCS to get better visibility of that

@vasily-kirichenko Don't we have to set mFSharp_maxMB environment variable in order to enable max memory checks https://github.com/fsharp/FSharp.Compiler.Service/pull/444/files#diff-d3c6e872b60cb8a91665cdd9d5e5ca27R65?

@dungpa You can set the MaxMemory property on FSharpChecker.  However, I'm not yet convinced that the max-memory trigger does anything sufficiently useful.

FCS 1.4.1 is now available with updates to the reactor and caching: https://github.com/fsharp/FSharp.Compiler.Service/pull/445


Telegraf interface?

I'm not sure where to ask about this...
I have several devices to which I have interface via Telegraf using JSON, which in turn connects to InfluxDB and then visualized in Grafana.  I have tried various combinations of syntax, many of which generate errors, but when the Telegraf config file is error-free, there's no output, possibly signifying a mismatch of keywords.
I can see that the USB-ethernet connection is collecting data, both by issuing a mosquitto_sub command on the host Raspberry Pi, and by running MQTT Explorer on a nearby Linux box.
Most of my interfaces use JSON input to Telegraf, and it looks like there's a JSON output option in MQTT Explorer, and I can specify JSON in my Telegraf config file, but perhaps there is a better option.
Any suggestions on a Telegraf config file that works with Aurora MQTT data?  Here is my Telegraf config file:
[agent]
  interval = "20s"
[[outputs.file]]
  files = ["stdout"]
[[inputs.mqtt_consumer]]
  servers = ["tcp://<IP_ADDRESS>:1883"]
  topics = [
  "/homie/aurora-180803112/abc/leaving-water-temperature"
  ]
  data_format json_v2 # or json (doesn't matter)

and here some debug output:
2022-11-24T21:33:17Z D! [agent] Initializing plugins
2022-11-24T21:33:17Z D! [agent] Connecting outputs
2022-11-24T21:33:17Z D! [agent] Attempting connection to [outputs.file]
2022-11-24T21:33:17Z D! [agent] Successfully connected to outputs.file
2022-11-24T21:33:17Z D! [agent] Starting service inputs
2022-11-24T21:33:17Z I! [inputs.mqtt_consumer] Connected [tcp://<IP_ADDRESS>:1883]
2022-11-24T21:33:27Z D! [outputs.file] Buffer fullness: 0 / 10000 metrics
2022-11-24T21:33:37Z D! [outputs.file] Buffer fullness: 0 / 10000 metrics
2022-11-24T21:33:47Z D! [outputs.file] Buffer fullness: 0 / 10000 metrics
2022-11-24T21:33:57Z D! [outputs.file] Buffer fullness: 0 / 10000 metrics
2022-11-24T21:34:07Z D! [outputs.file] Buffer fullness: 0 / 10000 metrics
...

I'm not sure what did it, but I stumbled upon a confguration that works:
[[inputs.mqtt_consumer]]
  interval = "303s"
  servers = ["tcp://<IP_ADDRESS>:1883"]
  persistent_session = false
  qos = 0
  topics = [
  "homie/aurora-180803112/abc/entering-water-temperature",
  "homie/aurora-180803112/abc/leaving-water-temperature",
  "homie/aurora-180803112/pump/waterflow",
  "homie/aurora-180803112/compressor/speed"
  ]
  data_format = "value"
  data_type = "float"


Template compiler: de-duplication of identical hoisted content

What problem does this feature solve?
Looking through the compiled output code of my app I noticed a lot of identical hoisted static content, like in this reproduction:
const _hoisted_1 = { class: "text-end" }
const _hoisted_2 = { class: "text-end" }
const _hoisted_3 = { class: "text-end" }
const _hoisted_4 = { class: "text-end" }
const _hoisted_5 = { class: "text-end" }
const _hoisted_6 = { class: "text-end" }

https://sfc.vuejs.org/#eNqNkstuwyAQRX9lNKtWis3eciL1P9jYdNw6Cg8BTv0Q/16wKxq3UuQdHA5XMwMLvhlT3gfCCmtP0twaTxeuAGoD4tY4d+boafQFqXeOl2WBBkKomXkutUckcUQaj0jTEWnOUs0eWo1bJ2xvPDjyw5bRS6OthwUsdRCgs1oCxzgmjukCgNDK+TiKczJeODYcX395m3m74yJzseNj5uOOT5lPOz5nPq+8ZlsHsXY84VZ8IRtTXp1W8WWXdJX/HDiOFawksbWnKi4+vTeuYsx1Iv2Hqyu1/WBxVdpB+V5SSU4WrdVfjmwM5nh6yGAR3skWNk6bLNlnmX/Uf7kpNnAVMHwDUCTfLw==
What does the proposed API look like?
While it's not a huge deal, it seems like an easy problem to fix, the template compiler just needs to keep a cache of previously emitted hoisted content. Unless there is a reason to not reuse hoisted content.

see https://github.com/vuejs/core/pull/3215


Sometime RPI3 wlan doesn't exist

At some boots the internal wlan rpi3 device doesn't exist:
not in ifconfig -a
not in nm devices

We can close this as I've never seen this again. We will reopen if needed.


[🐞] Missing attributes for event handlers in some elements

Which component is affected?
Qwik Runtime
Describe the bug
I am using mitosis as a build tool to get an output for qwik and it seems to compile with one issue, there is no onClick$ available for the div element and I cant seem to pass a normal event using onClick because it wouldn't be serialized
Reproduction
https://stackblitz.com/edit/qwik-starter-4gwtot?file=src%2Froutes%2Findex.tsx
Steps to reproduce
No response
System Info
System:
    OS: Linux 5.15 Manjaro Linux
    CPU: (4) x64 Intel(R) Core(TM) i5-2410M CPU @ 2.30GHz
    Memory: 510.73 MB / 5.74 GB
    Container: Yes
    Shell: 5.9 - /bin/zsh
  Binaries:
    Node: 18.12.1 - ~/.nvm/versions/node/v18.12.1/bin/node
    Yarn: 1.22.19 - ~/.nvm/versions/node/v18.12.1/bin/yarn
    npm: 8.19.2 - ~/.nvm/versions/node/v18.12.1/bin/npm
  Browsers:
    Firefox: 111.0

Additional Information
Div element or other display elements should have | support the onClick$ attribute

This line is invocating the console log directly:
    <div onClick$={console.log('Hello, the main div has been clicked')}>

instead, it needs to be wrapped in an arrow function:
    <div onClick$={() => console.log('Hello, the main div has been clicked')}>

Typescript is even complaining about it:

Oh thank you very much


Rename classes directories Mails and FilePond in lowecase

Renamed classes directories Mails and FilePond in lowecase

This is important on casesensitive filesystems until this PR gets merged:
https://github.com/wintercms/winter/pull/481


One change.

Thank you for making this awesome answer book. Just made a little change. Please review.

Please indent this code correctly.

Already indented the code. Please review. Thx.

Thx for it @smileqiao1988 .
But to be honest..a few problems still linger there..

a is a bad variable name, please avoid such thing.
a and result should be declared as the same type.
Keep variable declaration as close to its use as possible.(For example the variable result)
Expression a>=0 will always be true, as it's a unsigned int.
Please remove unnecessary syntax noises like { }

Do you mind making a double check?
You know we are attempting to improve some cool guy's code. If I merge your pull request too boldly, I'm afarid Mr @pezy would frown on me...
FYI, the code below can be used as a reference.
#include <iostream>
#include <string>

using std::string;
using std::cin;
using std::cout;
using std::endl;

void factorial(){
	unsigned num = 0;
	cout << "Please input a positive number: " << endl;
	cin >> num;
	cout << num;

	unsigned result = 1;
	if (num <= 33){
		while (num >= 1)
			result *= num--;
		cout << "!= " << result << endl;
	}
	else
		cout << " is out of range." << endl;
}

int main() {
	factorial();
	return 0;
}

Thanks @Mooophy 's effort.

Just wonder about the meaning of magic number 33. why it is the range?
!=, look like unequal. The output such as 0!= 1 will causing some guy to be puzzled...

some advice about this issue. please don't mind.  :ghost:

@smileqiao1988
@pezy and I carried out experiments to check the threshold for input. Below is what we got.
...
0!  =  1
1!  =  1
2!  =  2
3!  =  6
4!  =  24
5!  =  120
6!  =  720
7!  =  5040
8!  =  40320
9!  =  362880
10!  =  3628800
11!  =  39916800
12!  =  479001600     <-- threshold for unsigned int
13!  =<PHONE_NUMBER>    <-- overflow
14!  =<PHONE_NUMBER>0
15!  =<PHONE_NUMBER>000
16!  =<PHONE_NUMBER>8000
17!  =<PHONE_NUMBER>96000
18!  =<PHONE_NUMBER>728000
19!  =<PHONE_NUMBER>08832000
20!  =<PHONE_NUMBER>176640000
21!  =<PHONE_NUMBER>1709440000
22!  =<PHONE_NUMBER>777607680000
23!  =<PHONE_NUMBER>8884976640000
24!  =<PHONE_NUMBER>33239439360000
25!  =<PHONE_NUMBER>3330985984000000
26!  =<PHONE_NUMBER>26605635584000000
27!  =<PHONE_NUMBER>0418352160768000000
28!  =<PHONE_NUMBER>11713860501504000000
29!  =<PHONE_NUMBER>739701954543616000000
30!  =<PHONE_NUMBER>12191058636308480000000
31!  =<PHONE_NUMBER>177922817725562880000000
32!  =<PHONE_NUMBER>33693530167218012160000000
33!  =<PHONE_NUMBER>811886495518194401280000000
34!  =<PHONE_NUMBER>39604140847618609643520000000

Since the range for a unsigned int is something like : 0 to 4,294,967,295, 12 seems a good choice , 33 is just too big.

Agree with @Mooophy !
When we are programming , we should notice all kinds of safety , for example , integer overflow above!
I am learning Information Security at school!

@Mooophy Thank you for your nice suggestions. You are right. I do need to be aware of variable identifier's problem. That is a bad habit of me. :)
For the code, I did more modifications, please review.
But I still declared "num" as int for two reasons.

If not, the output will always be "0! is 1", when the input "num" is negative.
Input "num" is much more smaller than result. So no worry about the overflow problem.

Thank you again for doing the real calculation. When I was running my old code, I didn't really check if output is correct. P.S. I like that you said "cool guys' code" lol. Please let me know if there are other problems in this code.

 But the reason is that for input bigger than 33, the output is "num! is 0". I just assumed that it is a correct output whenever I saw a positive output lol. I should not avoid the dirty work later. So now it is magic 12.
And I changed the output form from "1!=1" to "1! is 1". Hope this can solve your concern.
Please don't hesitate to give me suggestions. And according to Mooophy's word, you are the cool guy. Please don't frown on Mooophy.  Thanks for your guys' awesome work.

@mudongliang Information Security!! sounds awesome lol. I am agree with ur idea too. That is why I put a range over there. But a wrong range in the previous version lol.


Bottom of cards is cut

(see the bottom stroke)
to reproduce, click on item in the carousel, hit back
https://github.com/kodadot/nft-gallery/assets/90852205/95ac14c7-0a1d-4486-ba94-f2202b1df9ec

👋🏻

not happening for me

@prachi00 did you reproduce the steps?

@prachi00 did you reproduce the steps?
still happens to me

yeah I did go back but it was still there

magically fixed probably


[Addons: Backgrounds] - Duplicating default color block

Describe the bug
The default color block in the backgrounds tab is being duplicated on every switch of a tab and when the default block is clicked
To Reproduce
Steps to reproduce the behavior:

Set up project
Apply the background addon globally in the addonjs and configjs
(May be a backward compatibility issue)

addDecorator(withBackgrounds([
  { name: 'twitter', value: '#00aced' },
  { name: 'facebook', value: '#3b5998' },
]));

The following way of adding backgrounds does not work in angular
addParameters({
  backgrounds: [
    { name: 'twitter', value: '#00aced'},
    { name: 'facebook', value: '#3b5998' },
  ],
});

Go to the background tab and click on the default block

Expected behavior
One default block should appear rather than many
Screenshots

System:

Framework: [Angular]
Version: [5.0.0-rc.6]

Also What is this:

Is that supposed to show up in the toolbar when using backgrounds?

This issue has been resolved and I am now seeing the expected result with higher versions.


fixed the popup card

Issue #587 and #601  Solved
Type of PR

Updated the card to make it more visible
[X] Bug fix
[X] Feature enhancement

Description
Fixed the bug where a line was not clearly visible in the popup card.
Screenshots / Videos (if applicable)
Before:

After:

I'm a contributor in gssoc and hacktoberfest.
Thank you for reviewing my pull request!

@Vaishnavi7854 I didn't assign you, but you made PR. It's too bad.


[incubator/fluent-cloudwatch] Add security context key

What this PR does / why we need it:
I want to run fluentd as the root user.
Because the default user is fluent.
Which issue this PR fixes
(optional, in fixes #<issue number>(, fixes #<issue_number>, ...) format, will close that issue when PR gets merged)
none
Special notes for your reviewer:
@jmcarp
@icereval
@kenden
Checklist
[Place an '[x]' (no spaces) in all applicable fields. Please remove unrelated fields.]

[x] DCO signed
[x] Chart Version bumped
[x] Variables are documented in the README.md

/lgtm


concepts in csv form need to be escaped

@MacyL, your concepts.csv is corrupted, as you can see when checking github output. The reason is simple: csv requires that if a comma appears inside a cell, that the cell is placed in "conten, conten" this form. So please make sure that you check all concepts. Alternatively, we can just specify the list in concepticon.

updated :)
There is one thing I need to check today, there should be 917 concepts, but I only have 911 concepts in the STEDT data.

we'll check this, once we go for the lexibank-framework, where we convert data to csv...

The STEDT and the source both are having some issues :

Glosses in STEDT data often have typo
There is a total of 909 concepts in STEDT raw data
Only 911 glosses in the appendix in source but Marrison claims that his dataset includes 917 concepts.
STEDT includes some entries that's only mentioned in the source as examples, so there are not many words link to this gloss.

My approach :

Combine concepts in the STEDT data and the source (done)
Fix the typo if it's only one entry in the raw data (now)
There are about 20 concepts that's not listed in the STEDT data but I can find the words in the appendix. I will add them into the raw data. (today)

No!

You are not allowed to fix typos inteh STEDT data!

This is against our principles in lexibank.
Instead, what you do is: add a row in the concepts.csv, where you specify the correct concepticon ID, or you add another column to the concepticon.csv: Concept_in_STEDT, so we can trace both of them.
No changes to the raw data are accepted, it has to be done by our data in etc/

what about the concepts that's documented in the resource but not in the STEDT data? another file or we ignore them?

If we don't have data for them, we can't include them. That's what it is. So they will be ignore already by the code. Unless you re-type off the whole book and offer it in some format, we stick with stedt and use what they give to us.

What you need to understand, @MacyL, is that we have some fundamental design principles in lexibank which are important to be faithful to sources, and those state that we do not cherry-pick data and do things in a transparent way. If you modify the source now, the source is no longer the same as offered by STEDT, so we can't trace it back. Instead, we modify obvious errors in stedt with our code (and the csv-files we have). So we correct the data in a transparent way, without modifying the original data (which is STEDT in this case).

We have three columns already : ENGLISH , ENGLISH_in_STEDT, ENGLISH_in_source.  I document in a notes.md file.
I have those concepts in the resource, I previous typed down in case we need them in the future. Those concepts are mapped with concepticon, but people won't find the corresponding words in csv data.

Okay, notes.md needs to be NOTES.md. I'd also ask you to submit all data you have NOW, and then switch to another branch in git. So you can make a formal pull request afterwards, okay?
As to the three columns, this is allright! We'll use the code to then select the right one and to convert to a good human-readable English concept.

for branching (having committed all you done currently):
$ git branch updating
$ git checkout updating

Later, git-push this as well, and then you can make a PR later.


feat: add rnn basic modules

Refactor Tensors to make it support nested structure.
Add Nest<T> and INestStructure<T> to enable better use of nest structures.
Add basic RNN modules.
Revise the implementation of TensorArray.

Note:
The ILayer.Call needs to be fully refactored in the future.
@DevNullx64 This PR partially refactors the Tensors, which is mentioned in #1088 . Please feel free to comment anything about that :). Since the target branch is a dev branch, this PR will be merged at once. But if there's disadvantages you catch, we could improve it before merging to master branch.
In this PR the implicit conversion from Tensors to Tensor is still kept because the main purpose of this PR is to support RNN. However I add a check when doing this implicit conversion. If a Tensors has more than one Tensor, then an exception will be thrown. In this way, some error will be visiable.

Quite not sure, but I think that by adding some class or interface, Nest can hold less. By exemple what is done with the NestType may, prehaps, done by splitting or generic type handling. I seen that "NestType.Node" can't use PackSequenceInternal(). Change class architecture can prehaps avoid possibility to call PackSequenceInternal() from a Nest that should currently have NestType.Node.
I hope to don't borring you to many, I will help you if you want.
After that, you've done a lot of work :) !
I'm loking for this pull.


Documentation on -Perfmon option should be added to Set-VMProcessor help

Documentation on -Perfmon option should be added. ( https://docs.microsoft.com/en-us/windows-server/virtualization/hyper-v/manage/performance-monitoring-hardware )

Document Details
⚠ Do not edit this section. It is required for docs.microsoft.com ➟ GitHub issue linking.

ID: 476ea856-4da3-298b-9fd7-2aaf22935d62
Version Independent ID: 4163eaf5-0adf-50b2-40c4-e357a5db7671
Content: Set-VMProcessor (hyper-v)
Content Source: docset/windows/hyper-v/Set-VMProcessor.md
Product: w10
Technology: powershell-windows
GitHub Login: @andreabarr
Microsoft Alias: v-anbarr

Hello, @LongJohnCoder
The issue is under investigation and you will be notified with any changes on the way.
Thank you for providing feedback.

@LongJohnCoder Thank you for your feedback. We cannot add this is a parameter to the document as this is generic for all processors. However, I have added a tip on how to enable performance monitor on intel processors and use the switch via PR# https://docs.microsoft.com/en-us/windows-server/virtualization/hyper-v/manage/performance-monitoring-hardware
Thanks
Sri

@LongJohnCoder The content has been updated in the light of your feedback, thank you.


[TRANSFERS] Add tests

Currently our SDK has no tests to Transfers.
You can find the official documentation for transfers here.

Issue fixed in PR #189.


service are not found while search in project page

Describe the bug

some service are not found like GST ASSESSMENT in project page which is added in company

Screenshots

https://www.berrycast.com/conversations/22bf4686-eea3-56da-88b5-b0d8faca7e25


conv/weights/Assign: Input tensor Cannot convert a tensor of type float32 to an input of type float32_ref

When freezing a model, I keep encounter the problem represented in the title.
After training's done, I use the following code to freeze the checkpoint to a pb file:
import os, argparse

import tensorflow as tf

# The original freeze_graph function
# from tensorflow.python.tools.freeze_graph import freeze_graph

dir = os.path.dirname(os.path.realpath(__file__))

def freeze_graph(model_dir, output_node_names):
    """Extract the sub graph defined by the output nodes and convert
    all its variables into constant
    Args:
        model_dir: the root folder containing the checkpoint state file
        output_node_names: a string, containing all the output node's names,
                            comma separated
    """
    if not tf.gfile.Exists(model_dir):
        raise AssertionError(
            "Export directory doesn't exists. Please specify an export "
            "directory: %s" % model_dir)

    if not output_node_names:
        print("You need to supply the name of a node to --output_node_names.")
        return -1

    # We retrieve our checkpoint fullpath
    checkpoint = tf.train.get_checkpoint_state(model_dir)
    input_checkpoint = checkpoint.model_checkpoint_path

    # We precise the file fullname of our freezed graph
    absolute_model_dir = "/".join(input_checkpoint.split('/')[:-1])
    output_graph = absolute_model_dir + "/frozen_model.pb"

    # We clear devices to allow TensorFlow to control on which device it will load operations
    clear_devices = True

    # We start a session using a temporary fresh Graph
    with tf.Session(graph=tf.Graph()) as sess:
        # We import the meta graph in the current default Graph
        saver = tf.train.import_meta_graph(input_checkpoint + '.meta', clear_devices=clear_devices)

        # We restore the weights
        saver.restore(sess, input_checkpoint)

        # We use a built-in TF helper to export variables to constants
        output_graph_def = tf.graph_util.convert_variables_to_constants(
            sess, # The session is used to retrieve the weights
            tf.get_default_graph().as_graph_def(), # The graph_def is used to retrieve the nodes
            output_node_names.split(",") # The output node names are used to select the usefull nodes
        )

        # Finally we serialize and dump the output graph to the filesystem
        with tf.gfile.GFile(output_graph, "wb") as f:
            f.write(output_graph_def.SerializeToString())
        print("%d ops in the final graph." % len(output_graph_def.node))

    return output_graph_def

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument("--model_dir", type=str, default="", help="Model folder to export")
    parser.add_argument("--output_node_names", type=str, default="", help="The name of the output nodes, comma separated.")
    args = parser.parse_args()

    freeze_graph(args.model_dir, args.output_node_names)

And it looks fine:
Converted 603 variables to const ops.
7851 ops in the final graph.

plus, the generated pb file is larger than the ckpt file but smaller than the size of meta plus ckpt together.
Then, I tried to load the pb to inspect the ops:
import argparse
import tensorflow as tf

def load_graph(frozen_graph_filename):
    # We load the protobuf file from the disk and parse it to retrieve the
    # unserialized graph def
    with tf.gfile.GFile(frozen_graph_filename, 'rb') as f:
        graph_def = tf.GraphDef()
        graph_def.ParseFromString(f.read())

    # Then, we import the graph_def into a new Graph and return it
    with tf.Graph().as_default() as graph:
        # The name var will prefix every op/nodes in your graph
        # Since we load everything in a new graph, this is not needed
        tf.import_graph_def(graph_def, name='prefix')
    return graph

if __name__ == '__main__':
    # Let's allow the user to pass the filename as an argument
    parser = argparse.ArgumentParser()
    parser.add_argument('--frozen_model_filename', default='../experiments/ft-ht/frozen_model.pb', type=str, help='Frozen model file to import')
    args = parser.parse_args()

    # We use our "load_graph" function
    graph = load_graph(args.frozen_model_filename)

    # We can verify that we can access the list of operations in the graph
    for op in graph.get_operations():
        print(op.name)

And the code throws the error:
Traceback (most recent call last):
  File "infer_pb.py", line 25, in <module>
    graph = load_graph(args.frozen_model_filename)
  File "infer_pb.py", line 15, in load_graph
    tf.import_graph_def(graph_def, name='prefix')
  File "/path/to/lib/python2.7/site-packages/tensorflow/python/framework/importer.py", line 406, in import_graph_def
    node, 'Input tensor %r %s' % (input_name, te)))
ValueError: graph_def is invalid at node u'resnet_v1_50/conv1/weights/Assign': Input tensor 'resnet_v1_50/conv1/weights:0' Cannot convert a tensor of type float32 to an input of type float32_ref.

Anyone could shed me some light? Thanks!

Hello, please refer to #3628 where the conversion issue is addressed.


mscolab export/import did not use configured "filepicker_default": "fs"

if we configure in mss_settings.json the "fs" filepicker this is currently for mscolab export/import ignored
To verify this you need a config file mss_settings.json to be stored in $HOME/.config/mss
{
 "filepicker_default": "fs"
}

The used QtWidgets.QFileDialog.getSaveFileName needs to be replaced by mss_qt.get_save_filename
also QtWidgets.QFileDialog.getOpenFileName by the one of mss_qt.
To compare how that file picker looks like, you can look at it by e.g. save of topview.
fix is needed for:
https://github.com/Open-MSS/MSS/blob/develop/mslib/msui/mscolab.py
and look also on the test.

Hey @ReimarBauer, can I work on this issue?


Unable to assume the service linked role

Creating the application in a new account I get the following error:
Resource handler returned message: "Invalid request provided: CreateCluster Invalid Request: Unable to assume the service linked role. Please verify that the ECS service linked role exists.

on a second deployment it worked

Hi @fabiopaiva,
I am just surprised with this error because CDK creates all the required roles with permissions. But I am glad it worked, have fun. Thanks.


Fix key bindings in 3d_gizmos example after camera controller

Objective
Fixes #14811
Solution

Switch D to T: T for "on top of"
Switch A to B: B in "AABB", or "boxes"

Testing

Ran the example locally
Checked the key bindings that the camera controller uses and made sure we're not using them in the 3d_gizmos example anymore

@tychedelia @alice-i-cecile could you please review when you get a chance? Thanks.

Much appreciated!


Some mp3 files not getting detected

I am trying to detect the mime type of audio file uploaded to my server running Ubuntu, node 0.10.33. For some valid mp3 files the mime type is not detected properly and application/octet-stream is returned.
I have attached a screenshot of the terminal window:

Do you have a copy of the mp3 I can test with?

Do you have a copy of the mp3 I can test with?

Thanks for the quick revert! Here is a file you can test with.
Happy new year!

Thanks for the quick revert! Here is a file you can test with.
Happy new year!

Ok, I see what the problem is now. The ID3 tag length is incorrect in that file. That mp3 file has a stored ID3 tag length of 4086 bytes, whereas the actual length is 5130 bytes. So when libmagic jumps to 4086 (4096 including the ID3 header) bytes in to look for the actual audio (mp3) header, it doesn't see the correct data so it never matches.
I'm not sure there is anything libmagic can do for corrupt files like this. One workaround might be to check the file description and if it detected it as an audio file with ID3 but the mime type is still application/octet-stream, use a utility like id3v2 to rewrite the id3v2 data. I did this via id3v2 --id3v2-only file.mp3, which only rewrites the id3v2 tag (leaves the id3v1 tag alone if there is one). After doing that, the length was corrected so the mime type was given correctly (and the description actually showed details on the audio format inside the file).

Ok, I see what the problem is now. The ID3 tag length is incorrect in that file. That mp3 file has a stored ID3 tag length of 4086 bytes, whereas the actual length is 5130 bytes. So when libmagic jumps to 4086 (4096 including the ID3 header) bytes in to look for the actual audio (mp3) header, it doesn't see the correct data so it never matches.
I'm not sure there is anything libmagic can do for corrupt files like this. One workaround might be to check the file description and if it detected it as an audio file with ID3 but the mime type is still application/octet-stream, use a utility like id3v2 to rewrite the id3v2 data. I did this via id3v2 --id3v2-only file.mp3, which only rewrites the id3v2 tag (leaves the id3v1 tag alone if there is one). After doing that, the length was corrected so the mime type was given correctly (and the description actually showed details on the audio format inside the file).

Thanks a lot!


Neo4J docker not starting with custom user and mounted directories

Operating System: MacOS 12.4
Neo4J docker image: 4.4.4+
docker version: 20.10.16, build aa7e414
Expected behaviour:

Neo4J starts inside the docker container successful

Actual behaviour:

Docker container crashes with error:
`Consider unsetting SECURE_FILE_PERMISSIONS environment variable, to enable docker to write to /logs.

Folder /logs is not accessible for user: 503 or group 20 or groups 20, this is commonly a file permissions issue on the mounted folder.
Hints to solve the issue:

Make sure the folder exists before mounting it. Docker will create the folder using root permissions before starting the Neo4j container. The root permissions disallow Neo4j from writing to the mounted folder.
Pass the folder owner's user ID and group ID to docker run, so that docker runs as that user.
If the folder is owned by the current user, this can be done by adding this flag to your docker run command:
--user=$(id -u):$(id -g)`

Steps to reproduce:
Start Neo4j-docker with version 4.4.4 or above using:
docker run \     --user $(id -u ${USER}):$(id -g ${USER}) \     --publish=7474:7474 --publish=7687:7687 \     --volume="$BASEPATH/neo4j/data":/data \     --volume="$BASEPATH/neo4j/logs":/logs \     --volume="$BASEPATH/../import/csv":/import \     --volume="$BASEPATH/conf":/conf \     neo4j:4.4.4
where $BASEPATH refers to the current directory incl. the given folders for logs, data and import with write privileges set for the current user as owner permissions
Root cause:
There was a change in the "docker-entrypoint.sh" script as of version 4.4.4 now using the "is_writable" function inside "check_mounted_folder_writable_with_chown". According to my investigation the owner of the folders inside the container is set to "root" even though the --user flag is passed to the container start. That leads to a mismatch when comparing the current user and the folder owner in the "is_writable" function.

This is really weird.
If I start a neo4j:4.4.4 container on Mac and stat /logs it shows the owner as root and permissions as 755, so of course the is_writable check returns false... but then if I ls /logs then (after a few tries) stat /logs returns the folder owner as 501??
My guess is that the docker desktop VM is introducing some kind of delay or has lazy file permissions that is causing stat to lie about the correct folder owner until you actually look inside the folder.
That makes me wonder how we were ever able to check file permissions correctly. I had a look to see what changed between 4.4.3 and 4.4.4, and it used to be that we used test -w $file to check for writability. If I try test -w /logs inside the container then it returns true.
I will change the writability check in docker-entrypoint.sh to use test -w, but I can't fix the underlying problem that Docker on Mac is doing some weird stuff to file/folder permissions.

Thanks, it now works for me, I tried Neo4j versions 4.4.4 and 4.4.11 (MacOS 12.6, M1 CPU).

Sorry, I take it back: 4.4.11 and 4.4.12 with a mounted /data directory and it fails with:
Consider unsetting SECURE_FILE_PERMISSIONS environment variable, to enable docker to write to /data.

Folder /data is not accessible for user: 501 or group 20 or groups 20, this is commonly a file permissions issue on the mounted folder.

@szarnyasg ah sorry that's my mistake for naming the PR badly.
I've fixed the source code for our docker image but I haven't pushed the updated docker images to docker hub. So unless you build the image yourself, it won't be fixed for you yet.
Generally I don't like to apply fixes to images that we've already released because people don't like things being changed underneath them and I don't want to risk introducing bugs via a docker cache update.
Just looking at our release schedule, 4.4.13 should be out some time next week, and that will have the relevant fix. There should also be a 5.1.0 release next week and that will have the fix as well.

@jennyowen Excellent, having the fix available next week works perfectly for me. I'll wait and test 4.4.13 then and let you know the result.

@szarnyasg it's looking like 4.4.13 won't make it out this week unfortunately. We did release 5.1.0 though, so you might have luck there.

4.4.13 is out and fixed this issue for me on MacOS 13.0.

@szarnyasg thanks for the update, I'm glad it works!


Clarify structure of implicit invitations.

Signed-off-by: George Aristy<EMAIL_ADDRESS>

@llorllale , can you please update this PR against the latest changes in master so it can be merged?

@dhh1128 done


Filter object in a raw fashion

Same comment for -f option.
Sometimes i get stuck into using this option without defining the parameter.
And from time to time even with defining the parameter to filter on, this is not working.
For instance: vsd list vminterfaces -f "associatedFloatingIPAddress == '<IP_ADDRESS>'"
or vsd list vminterfaces -f "VMUUID == '953d4b87-f927-40eb-a795-9d4f04f82106'" are not able to retrieve existing object.

This is most likely a VSD server issue. You should open an issue against vsd. Once it got fixed it'll work using the cli or the sdk.
Thanks,


More details about secrets

adding secret parsers and validators
using private key JWT secret

added more info to the secrets docs


Ignore configurations for constraints

What's changed?
As discussed offline, we need to be able to exclude certain configurations for constraint creation in certain cases (vulnerabilities etc).
What's your motivation?
Close our issue openend through slack on moderne.
Any additional context
I will raise fix for java-rewrite-dependencies
Checklist

[X] I've added unit tests to cover both positive and negative cases
[X] I've read and applied the recipe conventions and best practices
[X] I've used the IntelliJ IDEA auto-formatter on affected files

Thanks @Jenson3210 I've merged the whitelist proposal https://github.com/openrewrite/rewrite/pull/4233


HMR [ThemeProvider]

Version
1.0.5
Steps to reproduce
Just add theming to your application.
Expected Behavior
Hot reload application.
Actual Behavior

Little fix
ThemeProvider:40
if (this.context[CHANNEL]) {   this.unsubscribeToOuter(); }
||
define function unsubscribeToOuter previously, maybe in constructor ?
this.unsubscribeToOuter = () => ();
something like this...

Hmm, yeah that's because we use the life cycle hooks to subscribe and unsubscribe from context updates. The hack seems to work, but @gaearon might have a better idea how to properly fix this?

I don't see what is hacky there.
The code calls a function in componentWillUnmount that only exists under certain condition. This is not an issue with HMR, it's an issue that will occur in any app that unmounts top-level components.
The fix is to use the same condition in both cases?
(Also ThemeProvider is a bit over-engineered. React Broadcast has concept of "channels" because it is a generic utility. You only need a single "channel" because you are a single purpose tool. So there was no need to use "broadcasts" context field with multiple "channels", you just need to pass a single event emitter down. You can call your context field styledComponentsTheme or something like this.)

@gaearon check the code, I've long done that. Realized it as well!


GlobalOpt: optimize static properties with resilient types.

For example:
struct ResilientStruct {
  var singleField: Int
  public static let x = ResilientStruct(singleField: 27)
}

The generated (resilient) getter for x should just return a 27 (wrapped in a struct) and not lazily initialize a global variable.
The main SIL infrastructure change for this is to store type lowerings for multiple resilience expansions.
This lets the SIL optimizer reason about types (e.g. if a type is loadable) in specific functions.
For example, a type might be loadable in a resilient function, but not in an inlinable function.
rdar://problem/46712028

Build comment file:
Performance: -O

TEST
OLD
NEW
DELTA
RATIO

Regression

InsertCharacterEndIndexNonASCII
55
61
+10.9%
0.90x (?)

Improvement

StringToDataEmpty
700
650
-7.1%
1.08x (?)

Performance: -Osize

TEST
OLD
NEW
DELTA
RATIO

Improvement

Breadcrumbs.CopyUTF16CodeUnits.Mixed
68
57
-16.2%
1.19x

StringBuilderSmallReservingCapacity
379
338
-10.8%
1.12x

StringBuilder
364
328
-9.9%
1.11x

Performance: -Onone

TEST
OLD
NEW
DELTA
RATIO

Improvement

ArrayOfPOD
858
774
-9.8%
1.11x (?)

Code size: -swiftlibs

TEST
OLD
NEW
DELTA
RATIO

Improvement

libswiftAppKit.dylib
77824
69632
-10.5%
1.12x

libswiftDispatch.dylib
98304
94208
-4.2%
1.04x

How to read the data
The tables contain differences in performance which are larger than 8% and
differences in code size which are larger than 1%.
If you see any unexpected regressions, you should consider fixing the
regressions before you merge the PR.
Noise: Sometimes the performance results (not code size!) contain false
alarms. Unexpected regressions which are marked with '(?)' are probably noise.
If you see regressions which you cannot explain you can try to run the
benchmarks again. If regressions still show up, please consult with the
performance team (@eeckstein).

Hardware Overview
  Model Name: Mac Pro
  Model Identifier: MacPro6,1
  Processor Name: 12-Core Intel Xeon E5
  Processor Speed: 2.7 GHz
  Number of Processors: 1
  Total Number of Cores: 12
  L2 Cache (per Core): 256 KB
  L3 Cache: 30 MB
  Memory: 64 GB

--------------

Now that I think about it wouldn’t it make more sense to change SILGen to use the new SILFunction-specific entry point? Then you won’t need your new peephole at all. This was going to be my approach when I wanted to implement resilience-aware type lowering in SIL.

I experimented with that a bit, but it didn't work out. The reason is that the initializer of the resilient struct still has to return the struct indirectly. Only after inlining this initializer into the globalinit function the peephole can do its work.

I will fix the tuple case and add more tests in a follow-up PR. This GlobalOpt peephole is pretty limited and I cannot create test cases for more complex types with it. I'll use the new isLoadable API in other optimizations where I can create more test cases for it.

@swift-ci smoke test


[STREAMING][MINOR] Fix a duplicate "be" in comments

Can one of the admins verify this patch?

@rxin @zsxwing Would you take a look when you have time? Thanks!

@lw-lin it's not worth bothering with a PR for something this trivial. Consider running a bigger check for misspelling etc if you're going to. This still costs like an hour of attention across everyone just to process it.

Sure, I'll close this for now. Thanks for your time!

Thanks the PR is already here I've merged it.
@lw-lin in the future please batch more fixes like this. Thanks.

Sure. @rxin thank you for your review and patient guidance!


Improve State Management concepts in topics section in new docs repo

Will start with state management

Closing it as this has been added https://github.com/dapr/docs/tree/master/concepts/state-management


Bug fix/gibug fix/nwps 1613 fe be publication landing page display amendments

@smanivasag The first commit is the original change, but there was a double space in other part of the test, so it went back to me from Geraldine, I updated from the master to make sure it works with the last changes and that is why there is the "Merge 'master' branch".  I tried to eliminate the commits, but since it is the changes from Master, they still appeared. You can see in file changes that the one change and it has no conflicts in any other part.

@smanivasag The first commit is the original change, but there was a double space in other part of the test, so it went back to me from Geraldine, I updated from the master to make sure it works with the last changes and avoid conflicts and that is why there is the "Merge 'master' branch". I tried to eliminate the commits, but since it is the changes come from Master, they still appeared. You can see in file changes that the one change and it has no conflicts in any other part.

@FranciscoRuizHEE - Thanks for the details. Usually, when we merge maser and resolve conflicts, it would appear as one merge commit. Though the Files changed tab shows the correct file change, I am still a little nervous about the commit history and so, for the safer side, created a new PR #521 by cherry-picking only the necessary commit 1b81d65c2f8833e230e197d146687e257860f588. Could you review ?
Closing this PR as this has been superseded by #521, thanks


[Bug-fix] Mortality and t_cycle when shocks are read

Some months ago I did some work on the functionality that allows you to read pre-computed shocks.
I made a crucial omission of resetting t_age and not t_cycle when killing agents when one reads a shock that kills them.
This is a pretty serious bug. The upside is that it was introduced not that long ago in the grand scheme of things (9 months), and that the read_shocks feature is not used as often. I hope this did not cause trouble to anyone...
This patch fixes the issue.

[x] Tests for new functionality/models or Tests to reproduce the bug-fix in code.
[x] Updated documentation of features that add new functionality.
[x] Update CHANGELOG.md with major/minor changes.

Codecov Report
Base: 72.71% // Head: 72.79% // Increases project coverage by +0.08% :tada:

Coverage data is based on head (f377f51) compared to base (ae96a00).
Patch coverage: 100.00% of modified lines in pull request are covered.

Additional details and impacted files
@@            Coverage Diff             @@
##           master    #1181      +/-   ##
==========================================
+ Coverage   72.71%   72.79%   +0.08%
==========================================
  Files          72       72
  Lines       11764    11793      +29
==========================================
+ Hits         8554     8585      +31
+ Misses       3210     3208       -2

Impacted Files
Coverage Δ

HARK/Calibration/Income/IncomeTools.py
92.79% <100.00%> (ø)

...nsumptionSaving/tests/test_IndShockConsumerType.py
78.55% <100.00%> (+1.81%)
:arrow_up:

HARK/core.py
91.48% <100.00%> (+0.01%)
:arrow_up:

HARK/ConsumptionSaving/ConsIndShockModel.py
79.47% <0.00%> (+0.20%)
:arrow_up:

Help us with your feedback. Take ten seconds to tell us how you rate us. Have a feature suggestion? Share it here.

:umbrella: View full report at Codecov.
:loudspeaker: Do you have feedback about the report comment? Let us know in this issue.

@sbenthall this might be related to #1084

@wdu9, could you review this?

@sbenthall this might be related to #1084

Maaaybe but the bug was introduced after that issue was created. So maybe related but unlikely to fix it.

Looks good.

I've corrected the typo that Will identified and merged the latest master.
I'll merge after tests are done if there are no objections.


SideMenu is not presented modally

New Issue Checklist

I have read the guidelines for contributing and I understand:

[x] My issue is happening in the latest version of SideMenu.
[x] My issue was not solved in the README.
[x] My issue can not be answered on stackoverflow.com.
[x] My issue is not a request for new functionality that I am unwilling to build and contribute with a pull request.
[x] My issue is somehow not reproducible in the demo project.

Issue Description

So what I am trying to achieve is to control multiple view controllers with one side menu and every one of those can open the side menu. So every view controller has a Segue that modally presents the Side Menu. And the the Side Menu has a show-Segue to every one of those viewcontrollers. One of the ViewControllers is the initial. The first time I open the SideMenu everything works fine. But when I navigate to one of the other ViewControllers and then open the side menu it just pushes on to the screen like its "shown" not presented modally. I read through the entire example but couldn't find drastic differences. What am I doing wrong ?
Thanks for your help and sharing this awesome project !
Greetings from Germany

Everything you need to know is in the README. Please read it carefully.


Fix duplicate CountVectorizersFeaturizer in supervised_embeddings pipeline

Status (please check what you already did):

[x] made PR ready for code review
[x] updated the changelog

@wochinge You were right. Reviewed the defaults for CountVectorFeaturizer and it should use word analyzer + 4-gram char analyzer. So the existing config is correct.


Why is the argument of BehaviorSubject not optional? (d.ts)

Bug Report
Current Behavior
The creation of an instance of BehaviorSubject requires to pass the initial value.
But this should be an optional parameter. Like in JavaScript.
Reproduction
Try to create BehaviorSubject without any arguments in TypeScript.
let subject = new BehaviorSubject();

Expected behavior
I expected the same behavior like in JavaScript. The type file should be accept empty initial arguments. Evaluating as undefined? In this case the subscriber should not notificated with the initial value.
Environment

Ionic CLI 3.20.0
Ionic angular 3.9.2
cordova 8.0.0
ionic/app-scripts: 3.1.9
npm 5.5.1
os Windows 10

Possible Solution
The constructor argument of BehaviorSubject initial value should be optional.
In JS you get no error if no argument is passed.
Workaround could be:
new BehaviorSubject (undefined)

This behaviour is by-design.
The BehaviorSubject class implements a subject that has a current value and, for that reason, an initial value is required.
If you need a subject which doesn't have an initial value, use Subject.
To have an undefined initial value, you can use BehaviorSubject like this:
const subject = new BehaviorSubject<number | undefined>(undefined);
subject.subscribe(value => console.log(value));
subject.next(1);

Which will log:
undefined
1


Fix issue with e() function not accepting arrays as arguments

Previously, the e() function in Laravel was throwing an error when an array was passed as its first argument. This was due to the fact that the function only accepts strings as its input. To fix this issue, the code was modified to check if the input is an array, and if so, it was encoded as a JSON string using json_encode().
Almost all sites built with Laravel get this error. For example laracasts.com, forge.laravel.com, filamentphp.com
There are the error screenshots when trying to pass array to parameters:

Trying to pass an array to email input

oops

This ensured that the e() function could safely handle arrays and strings.
before implement:

after:

p/s: if the code of PR is not satisfactory, you (the core team) can fix this error yourself.

I don't think manually changing a parameter a site does not expect, and then expect it to work properly would be a valid bug report.
I agree a site owner could, if they anticipate someone manually trying out unwanted input parameters, handle with a redirect, but that is beyond, such as Google does
https://www.google.com/search?q[]=test
(in Google's case I assume they don't recognize q[] a parameter at all, and redirect due to a missing q parameter, but still)
IMHO, this is something a developer afraid of this use case can already handle within its app's exception handler.
https://laravel.com/docs/10.x/errors#the-exception-handler

There are a lot of reasons completely unrelated to e() that would cause a 500 to be thrown when you pass in an array instead of a string parameter. Especially search queries!
It's not the responsibility of the framework to handle unexpected input. That is 100% on the developer.
I can also see this causing security issues - blindly returning an entire array or object rather than failing because the dev forgot to specify which value from a model they wanted.
Consider what e($user) could return...

Json_encode is not safe, use JS::from instead


Unsigned to signed int comparison [-wSign-compare]

ld.cpp:38:21: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
  for(uword i = 0; i < nCausal; i++){

Probably okay. This comes from the counter in RcppArmadillo.

For some reason PKG_LIBS= -Wno-sign-compare  in src/Makevars doesn't seem to have an effect.


Replace host and port metric tags with hostAddress?

I'm not sure there is any utility in having a separate port tag. If the tag is concatenated, then you could find all instances of a metric on the same host by using a tag query with a wildcard (hostAddress LIKE localhost*) or find the metric for a specific instance by using the host and port in the tag query.

I would be curious if we would lose any comparison functionality by having to query via regex/wildcard vs selecting an available tag value.

So, we might not need to do this. I wouldn't suggest anyone work on this yet.

Was curious if this could be done w/ a MeterFilter.  So tried writing the following which seems like it may work, but have not tested.  Just wanted to get some hands on experience w/ MeterFilters as I have never written one.
        MeterFilter filter = new MeterFilter() {
            @Override
            public Meter.Id map(Meter.Id id) {
                var hostVal = id.getTag("host");
                var portVal = id.getTag("port");
                if(hostVal != null && portVal != null) {
                     var newTags = id.getTags().stream()
                             .filter(tag->!tag.getKey().equals("host") && !tag.getKey().equals("port"))
                             .collect(Collectors.toList());
                     newTags.add(new ImmutableTag("hostPort", hostVal+":"+portVal));
                     return id.replaceTags(newTags);
                } else {
                    return id;
                }
            }
        };

Was just experimenting with this, we should make this change if its the best default.   Not sure what the best default is. I can not think of an use case for the stand alone port tag.  As mentioned earlier there may be a case for having a drop down of available severs w/o ports to choose from, which the standalone host tag would support.

I think that the standalone host tag provides value. The port tag seems extraneous.
I agree with @keith-turner that there would be a valid use-case for having a drop-down list of hostnames that a user could select.
That's a pretty common pattern with grafana dashboards that show cross-application metrics filtered down to a single host.


Optimistic Http Hydrate PoC

[x] it works in at least one case
[x] tests pass

We could close: https://github.com/massdriver-cloud/artifact-definitions/pull/139

Making sure mass schema dereference still works with refs to local types.

Closing, we won't support this in types


Pip install error

https://github.com/Yomguithereal/ipysigma/blob/6f92e6248387106a988c728fb0df6615ea34d5c3/setup.py#L139
Looks like it should be:
        ('etc/jupyter/nbconfig/notebook.d' ,['ipysigma.json'])
Trying to pip install on Windows (Win10) gives the following error:
    Traceback (most recent call last):
      File "<string>", line 1, in <module>
      File "C:\Users\sb282\AppData\Local\Temp\pip-install-u4fzz9r4\ipysigma\setup.py", line 177, in <module>
        setup(**setup_args)
      File "C:\conda\envs\jpr\lib\site-packages\setuptools\__init__.py", line 145, in setup
        return distutils.core.setup(**attrs)
      File "C:\conda\envs\jpr\lib\distutils\core.py", line 148, in setup
        dist.run_commands()
      File "C:\conda\envs\jpr\lib\distutils\dist.py", line 955, in run_commands
        self.run_command(cmd)
      File "C:\conda\envs\jpr\lib\distutils\dist.py", line 974, in run_command
        cmd_obj.run()
      File "C:\conda\envs\jpr\lib\site-packages\setuptools\command\install.py", line 61, in run
        return orig.install.run(self)
      File "C:\conda\envs\jpr\lib\distutils\command\install.py", line 557, in run
        self.run_command(cmd_name)
      File "C:\conda\envs\jpr\lib\distutils\cmd.py", line 313, in run_command
        self.distribution.run_command(command)
      File "C:\conda\envs\jpr\lib\distutils\dist.py", line 974, in run_command
        cmd_obj.run()
      File "C:\conda\envs\jpr\lib\distutils\command\install_data.py", line 56, in run
        dir = convert_path(f[0])
      File "C:\conda\envs\jpr\lib\distutils\util.py", line 127, in convert_path
        raise ValueError("path '%s' cannot end with '/'" % pathname)
    ValueError: path 'etc/jupyter/nbconfig/notebook.d/' cannot end with '/'

Hello @sanbales. Maybe so, this is coming from jupyter's templates, but they may be wrong indeed. Does this fix the issue for you? If so, do you want to open a PR fixing the issue?

Will do.


the tags are python while the game is written in c

please fix this or i will walk over to your room and beat you up
im serious

ok fixed my b

do better next time


New dbcontext queue

Overview
This PR includes the following proposed change(s):
Plan trip page is working with queue now.
Type of change

[x] Bug fix (non-breaking change which fixes an issue)
[x] New feature (non-breaking change which adds functionality)
[ ] Refactoring / Documentation
[ ] Version change

if your change is a breaking change, please add breaking change label to this PR
How Has This Been Tested?
Please describe the tests that you ran to verify your changes.
Screenshots
Please add any relevant UI screenshots if applicable.
Checklist:

[x] My code follows the style guidelines of this project
[x] I have performed a self-review of my own code
[ ] I have made corresponding changes to the documentation
[ ] New and existing unit tests pass locally with my changes

work was carried over via #966