fsprojects / .github Goto Github PK

The original fsprojects/fsharp-language-server repo seems completely unmaintained. I have forked it and republished the extension with a large number of improvements (probably a few extra bugs too :b ), from myself and other members of the community.

As requested in this issue faldor20/fsharp-language-server#15 , would it be possible to merge the two projects, or replace the old one, or some such, so that members of the community have less confusion and duplication?

Thanks.

I lost access to the organization and therefore my repo at github.com/fsprojects/Interstellar due to not having 2FA enabled, which I've since fixed. Is there a way I can get access back?

During last Office Hours in FSSF Slack we've discussed the idea of promoting bounties as a model of monetizing OSS and getting more contributors to F# projects.

For those unfamiliar with bounty model here is basic workflow:

1. I have a feature that would make my life easier (or bug that annoys me)
2. I post announcement that this feature is backed by donation
3. crowd could increase bounty
4. devs monitor that board and grab it.

Few points, that are summing up discussion.

1. The idea is not affiliated with FSSF as such, nor assumes FSSF putting any funds into it
2. We would like to promote BountySource (or any other vendor providing similar service) as a common, "right" way to use by F# projects, so we can easily create more active community participating in both creating / funding bounties and contributing fixes so the bounties can be claimed
3. We would like to have a common place (for example as part of fsrpojects webpage) where people can easily find available bounties.
4. Bounties model focuses on particular issues, so shouldn't be mistaken with any reliable way of funding project or providing commercial support

Hello,

Unfortunately, I have already polluted the NuGet namespace with FSharp.Foo packages before I found and read the guideline.

Since few people expect for me use those libraries, I'm considering either

1. transfer the ownership to fsprojects and become a maintainer, taking responsibility.
2. or rename them completely.

In particular, FSharp.Span.Utils seems falling into option 1; it's very small so that I can easily add docs and maintain, and thankfully some people liked it (not sure if it is actually used, though).

Can I transfer it to fsprojects?

Please, add https://github.com/YaccConstructor/YC.PrettyPrinter to fsprojects.

• CI build is configured.
• Documentation is created.
• Based on ProjectScaffold.
• Discussion on renaming to FSharp.Text.PrinterCombinators.

I started learning F# and this cheat-sheet was recommended to me and comes in and the top of searches (so it has some history) but I've found it largely out of date.

fsprojects/fsharp-cheatsheet#13 (comment)

I would be interested in updating it over time and @bartelink has offered to be a quiet second.

Please add F# 3D Math library to the list of F# projects:
https://github.com/eloraiby/FsMath3D

We have been working on this for about 100 hours now. It's been a good vehicle for learning F# and also might be of use to the community:

https://github.com/shaunluttin/algorithms/tree/master/articles/functional-programs-for-generating-permutations

The FSharp solution contains implementations and tests of permutation algorithms from this paper:

https://github.com/shaunluttin/algorithms/blob/master/articles/functional-programs-for-generating-permutations/article.pdf

Recently, I created the organisation fsharp-mobile. It aims to regroup all the efforts around improving toolings and frameworks for desktop and mobile development with F#.

I am already hosting most of the work I did over the years such as the F# mobile templates, 3rd party support and additional variants for Fabulous.

I would also like the main Fabulous repository to join this organisation if that's okay.

Hi, I am interested in becoming a maintainer of the FsLexYacc project. We are actively using the tools.

Hello,

I currently work on a library which I call "FsLocalState". The repo is here, and there is a description and some samples in the README.

Basically, it's about composing 'state-aware' functions as if they were just normal functions. Initially, I did that for signal processing and physics simulation, where is always a lot of state involved, with non-linear computations, e.g. when designing filters or modeling and numerically solving differential equations. But it's quite generic, and I guess it could be useful for other applications - not only in the "working with data series" domain. Another brief idea I had was creating a view engine and investigate how this relates to other approaches like react / virtual dom or Svelte/Sutil-like things. Maybe some other people are interested in this, too, and come up with other use cases - who knows...

If you think that this library would fit in fsprojects, then I could move it here?

Thanks, and have a nice sunday!

The layout of https://fsprojects.github.io/ occludes the project names. There is no point in a list of names that clips the names.

TickSpec is a mature open source testing library for .Net written in F#.
The original repository was held on CodePlex which is closing down soon.
Some users of the library have created their own clones of the repository on GitHub, others are unsure which repository to use, see thread:

• https://twitter.com/ChaloupkaMilos/status/903169577210830848

I propose that the following repository is transferred to fsprojects as a common repository:

• https://github.com/bartelink/tickspec

That way users can merge changes to a common repository.

I'd love to have Interstellar moved over here to fsprojects!

Related: fsharp/fsharp.org#854

Hello all,

I forked the shmew/Feliz.Plotly repository and updated dependencies and Feliz api calls. I also created a pull request here. This pull request was created on March 8, 2023 and updated dependencies as well as removed webpack in favor of vite.

You can view documentation here: https://everybodykurts.github.io/Feliz.Plotly

Please let me know if you need any additional information.

Kurt

fsprojects/FSharp.Json#65 and fsprojects/FSharp.Json#61 (comment)

https://github.com/orgs/fsprojects/teams/fsharplus-admin
Add the users @adz and @wallymathieu

That project probably needs a new team, as well, that should include @forki and @cloudruntime.

Hello, I'd like to be added as the maintainer of GraphProvider. I use DGML routinely for domain modeling.

We should gradually make more "fsprojects" and other F# community libraries available as portable libraries (profile 7, 78 or 259). Portable libraries are consumable by both .NET Core and .NET Framework projects, as well as Windows apps and so on. Looking ahead it seems pretty important that we maximize the reach of F# libraries where possible. This will be a fairly long process but it will be worth it.

For example, we made FSharp.Control.AsyncSeq available as both a .NET 4.5 and Profile7 PCL in this PR. We could have made it only a Profile7 but decided to do both for the moment.

FsRandom is an fsharp library to generate random numbers in the way of functional programming including computation expressions.
It is extensible to support adding pseudo-random number generators and random functions such like generating random passwords or random user names.
Also, it can leverage System.Random class and its subclasses defined in libraries like MathNet.Numerics.

Hi, would it be possible to get FSharpLint into fsprojects? https://github.com/duckmatt/FSharpLint/issues/28

@sergey-tihon From time to time people ask if it would be possible to fork-and-reboot an apparently-abandoned F# community project (e.g. in a personal repository) into fsprojects.

In general in the past we've never had to do this as project owners have either decided to move in or not. However it's a scenario we should think about, and probably have some reasonable policy guidelines.

Some notes:

• Fork-and-reboot on active projects is generally really bad, but is seen as reasonable for abandoned projects.
• Forking loses issues, PRs etc. Also loses access to be able to publish nuget packages and will lose package continuity

cc @cartermp

Hi, can I transfer https://github.com/jbfp/fsharp-dnx-templates to fsprojects? :)

i wanna move https://github.com/panesofglass/FSharp.Data.JsonSchema into fsproject. Im reaching out to the author cuz i dont wanna see this project die out. Writing this issue a lil preemptively while i get maintainer access to the repo

Related: fsprojects/FsHttp#79

Although there are still some TODOs open before transferring and releasing the next major, I would be happy to transfer FsHttp to fsprojects.

Thank you for maintaining this space.

Dear Maintainers,

Recently we created new NuGet account fsprojects that is owned by @fsprojects/owners group (that have a full control over all fsprojects organization)

The goals of this account are:

• be sure that we are able to restore access to packages in the case of emergency
• to have a backup account that can take over in case some important package is not maintained

This account will not be used for publishing new version of the package.

If you are agree with goals, please feel free to add fsprojects to owners list of your fsprojects's packages.
@theburningmonk @ovatsus @colinbull @forki @luajalla @ptrelford @nelak @lasandell @panesofglass @dmitry-a-morozov @jbtule @dsevastianov @mavnn @ReedCopsey @duckmatt
@mausch @kimsk @dmohl @dtchepak @pezipink

Current state:

• Amazon.CloudWatch.Selector
• Amazon.SimpleWorkflow.Extensions
• ApiaryProvider
• Cricket
• DynamicsCRMProvider
• DynamicsNAVProvider
• DynamoDb.SQL
• ExcelFinancialFunctions
• ExcelProvider
• Filbert
• Foogle.Charts
• FAKE.*
• Foq
• FsBlog
• FSharp.Collections.ParallelSeq
• FSharp.Compatibility
• FSharp.Compiler.CodeDom
• FSharp.ComProvider
• FSharp.Configuration
• FSharp.Control.Reactive
• FSharp.Data.DbPedia
• FSharp.Data.Experimental.XenomorphProvider
• FSharp.Data.HiveProvider
• FSharp.Data.SqlClient
• FSharp.Data.Toolbox
• FSharp.Desktop.UI
• FSharp.Linq.ComposableQuery
• FSharp.Management
• FSharp.Numerics.FuzzyIntervals
• FSharp.Quotations.Evaluator
• FSharp.TypeProviders.StarterPack
• FSharp.ViewModule
• FSharpLint
• FSharpx.*
• FSharpx.Observable
• FsLexYacc
• FsReveal
• FsUnit
• GraphProvider
• Paket
• S3Provider
• SQLProvider
• Tamarin
• FnuPlot
• FsXaml
• Oxen
• AzureStorageTypeProvider
• Chessie
• FSharpx.Extras
• FSharp.Core.Fluent
• FSharp.CloudAgent
• FSharp.Interop.Dynamic
• FSharp.Core.Fluent
• FSharp.Control.AsyncSeq
• FSharp.Text.RegexProvider

Hi, let's do it. Do I need to wait for approval or find a new maintainer or can I just press the button and make the transfer to kick things off?

hello, can I transfer FSharp.Data.Xsd?

Could we please move BioProviders to fsprojects? Recommended here. Thank you!

We've written a queue based on redis in f#, and we would like to add it to fsprojects.

It's based on OptimalBits/bull.

The repository is here: http://github.com/curit/oxen and the docs site is here: http://curit.github.io/oxen/

fsprojects/FSharp.Codecs.Redis#5

Let's use this issue to document how to switch to .NET-Core based tooling in "fsprojects" repos. A good measure of this is if "mono" is no longer required in the repo at all (except maybe for testing)

.NET Core Paket

Typical commands to acquire and run paket:

dotnet tool install paket --tool-path .paket
.paket\paket restore

.NET Core FAKE

dotnet tool install fake-cli --tool-path .fake --version 5.12.6
.fake\fake run build.fsx

Switching to FAKE 5

Many "fsprojects" repos use FAKE 4. See https://fake.build/fake-migrate-to-fake-5.html

At top of build.fsx you'll need this:

#r @"paket:
source https://nuget.org/api/v2
framework netstandard2.0
nuget Fake.Core.Target
nuget Fake.Core.ReleaseNotes
nuget Fake.DotNet.Cli
nuget Fake.DotNet.AssemblyInfoFile
nuget Fake.Tools.Git //"

#if !FAKE
#load "./.fake/build.fsx/intellisense.fsx"
#r "netstandard" // Temp fix for https://github.com/fsharp/FAKE/issues/1985
#endif

Notes:

• Delete build.fsx.lock whenever you update dependencies
• Note the strange //" on the last line, used by FAKE to detect the Paket section in the script

Typical opens:

open Fake 
open Fake.Core.TargetOperators
open Fake.Core 
open Fake.Tools.Git
open Fake.DotNet
open Fake.IO
open Fake.IO.Globbing.Operators
open System
open System.IO

Typical code changes. When in doubt search for the old identifier in FAKE repository source

open Fake.Git    --> open Fake.Tools.Git
open Fake.ReleaseNotesHelper --> remove

parseReleaseNotes --> ReleaseNotes.parse  (open Fake.Core)
Target  --> Target.create   (open Fake.Core)
CreateFSharpAssemblyInfo --> AssemblyInfoFile.createFSharp  (open Fake.DotNet)
Attribute.Title --> AssemblyInfo.Title (open Fake.DotNet)
CleanDirs --> Shell.cleanDirs  (open Fake.IO)
!! -->   open Fake.IO.Globbing.Operators
Paket.Pack --> Paket.pack (open Fake.DotNet.Paket)
toLines --> String.toLines
fullclean --> Repository.fullclean  (open Fake.Tools.Git)
copyRecursive --> Shell.copyRecursive
stageAll --> Staging.stageAll
commit --> Commit.exec
DoNothing --> ignore
tracefn --> Trace.tracefn
RunTargetOrDefault --> Target.runOrDefault

Things with no alternative:

executeFSIWithArgs

Other notes:

• Paket.pack will need an explicit ToolPath for .NET Core paket tool local install, e.g.

let paketToolPath = __SOURCE_DIRECTORY__ + (if Environment.isWindows then "\\.paket\\paket.exe" else "/.paket/paket")

Target.create "NuGet" (fun _ ->
    Paket.pack (fun p -> 
        printfn "p.ToolPath = %A" p.ToolPath
        { p with 
            ...
            ToolPath = paketToolPath
        .... })
)

Typical build.cmd and build.sh

Each repo normally has a build.cmd and build.fsx that first acquire FAKE and Paket:

build.cmd:

@echo off
dotnet tool install fake-cli --tool-path .fake --version 5.12.6

dotnet tool install paket --tool-path .paket

.paket\paket.exe restore
if errorlevel 1 (
  exit /b %errorlevel%
)

.fake\fake.exe run build.fsx %*

build.sh:

#!/bin/bash
if test "$OS" = "Windows_NT"
then
  cmd /C build.cmd
else
  dotnet tool install fake-cli --tool-path .fake --version 5.12.6
  dotnet tool install paket --tool-path .paket

  .paket/paket restore
  exit_code=$?
  if [ $exit_code -ne 0 ]; then
    exit $exit_code
  fi
  
 .fake/fake run build.fsx $@
fi

Generating .NET Framework binaries without having Mono installed

Use this netfx.props - updated so it doesn't need Mono: https://github.com/fsprojects/FsLexYacc/blob/2f9f06a1fe327e2c334abc6b76b60cce697b78d2/netfx.props

If your project contains .EXE tools

Projects such as FsLexYacc include binary tools in their output nuget packages, and a targets file to use these

1. Add a "publish" step, e.g.

   dotnet public -c Release -f netcoreapp2.0 src\FsLex\fslex.fsproj
   

2. Include the binaries in the nuget package, e.g.

   ../src/FsLex/bin/Release/net46/publish ==> build/fslex/net46
   ../src/FsLex/bin/Release/netcoreapp2.0/publish ==> build/fslex/netcoreapp2.0
   ../src/FsYacc/bin/Release/net46/publish ==> build/fsyacc/net46
   ../src/FsYacc/bin/Release/netcoreapp2.0/publish ==> build/fsyacc/netcoreapp2.0
   

3. Adjust the targets to start the right binary using the right runner, e.g.

	<PropertyGroup>
               .....
		<FsLexToolPath Condition="'$(FsLexToolPath)' == '' AND '$(MSBuildRuntimeType)'!='Core'">$(MSBuildThisFileDirectory)/fslex/net46</FsLexToolPath>
		<FsLexToolExe Condition="'$(FsLexToolExe)' == '' AND '$(MSBuildRuntimeType)'!='Core'">fslex.exe</FsLexToolExe>
		<FsLexYaccToolRunner Condition="'$(UseFsLexYaccToolRunner)' != 'false' AND '$(FsLexYaccToolRunner)' == '' AND '$(MSBuildRuntimeType)'!='Core' AND '$(OS)' == 'Unix'">mono </FsLexYaccToolRunner>

		<FsLexToolPath Condition="'$(FsLexToolPath)' == '' AND '$(MSBuildRuntimeType)'=='Core'">$(MSBuildThisFileDirectory)/fslex/netcoreapp2.0</FsLexToolPath>
		<FsLexToolExe Condition="'$(FsLexToolExe)' == '' AND '$(MSBuildRuntimeType)'=='Core'">fslex.dll</FsLexToolExe>
		<FsLexYaccToolRunner Condition="'$(UseFsLexYaccToolRunner)' != 'false' AND '$(FsLexYaccToolRunner)' == '' AND '$(MSBuildRuntimeType)'=='Core'">dotnet </FsLexYaccToolRunner>
	</PropertyGroup>

...
		<Exec Command="$(FsLexYaccToolRunner)&quot;$(FsLexToolPath)\$(FsLexToolExe)&quot;  -o &quot;$(FsLexOutputFolder)%(FsLex.Filename).fs&quot; %(FsLex.OtherFlags) %(FsLex.Identity)"/>

Documentation generation

Problems

• At time of writing FSharp.Formatting is not yet able to produce docs for netstandard2.0 DLLs. Therefore the only option for producing docs is to make net46 or similar DLLs as part of your build.

• At time of writing, both the fsformatting.exe tool (normally driven by FAKE FSFormatting module) and the FSharp.Formatting libraries (normally driven by a generate.fsx script) are .NET Framework only. This means documentation generation must run on NET Framework.

Recommendations:

1. switch to docsrc and docs for github pages, e.g. see the revised ProjectScaffold

2. Get rid of generate.fsx and move to structure similar to ProjectScaffold doc generation

3. If still using generate.fsx then make sure generate.fsx is not a FAKE script and only generate docs using Windows. If necessary manually generate docs using fsi docsrc\generate.fsx rather than doing it from FAKE 5

Testing

TBD

Building net4x libraries

TBD

Examples:

• fsprojects/FsLexYacc#92

The more the merrier! Would be sweet to have help when it comes to Fable related workflows, see fsprojects/FSharpPlus#392 for instance.

What do you think @cannorin @forki @gusty @adz ?

fsprojects/SyntacticVersioning#34

I'm interested in being the primary active maintainer for this repo.

Hi,

I've worked on this library - repo is here. A description of the library's goals and performance benchmarks compared to many other .NET collections are located here comparing this to most .NET collection libraries I could possibly find. Its been in some large production systems for a number of years now and its speed has made some of our programs viable in F# so its mostly stable at this point.

The library is an effort to reduce the penalty of immutability for both fun and for profit - to reduce the cost of immutability as much as possible (specifically speed) but keep its advantages.

I'm considering moving this to FsProjects as over the years there's been a lot of feedback around slow collection types in F#, specifically the Map over the years. In my personal use cases; this work has made F# feasible to use - it may help others as well.

It's pretty much an optimised HashMap/HashSet (HAMT) with specific modifications for the .NET runtime, with plenty of performance tuning iterations in an attempt to squeeze out as much performance as possible.

If you think this library is a good fit for fsprojects; happy to move it here. If not happy to hear that discussion as well of potential alternatives.

Thanks.