WebApiTest
the-ray-tracer-challenge-fsharp
WebApiTest | the-ray-tracer-challenge-fsharp | |
---|---|---|
4 | 10 | |
49 | 19 | |
- | - | |
1.8 | 4.0 | |
about 2 years ago | 7 months ago | |
F# | F# | |
- | MIT License |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
WebApiTest
-
Looking for enterprise level open source RESTful F# (sample) projects
Hello, not necessarily Rest or Websocket, but I have implemented an example of how to structure a sustainable enterprise web api. You can check it out here: https://github.com/bigby-the-wolf/WebApiTest.
-
Sustainable Web API example
I have also implemented something similar in F#, you can find it here.
-
Really great example projects?
Maybe this would interest you https://github.com/bigby-the-wolf/WebApiTest.
-
Namespace not defined
You can find the repo here: https://github.com/MrGodlike6/WebApiTest
the-ray-tracer-challenge-fsharp
-
Good book to learn F#?
Take a book that is project-based, such as The Ray Tracer Challenge, no matter what language it uses in the book, and start going through the book in F#. I have done so, for example, here is my in-work F# implementation for the ray tracer book.
-
OCaml at First Glance
Yes, please do! Warning: F# will ruin other languages for you. I find it rather painful to work in basically anything else after using F#, with gradients of pain for different languages. Haha.
And that's a good question. I have basically every book written on F#, but I can't say I have ever used them for anything more than reference.
The official docs/guide/reference are actually really good, and I refer to them a lot when using some feature I'm not familiar with: https://docs.microsoft.com/en-us/dotnet/fsharp/what-is-fshar...
F# For Fun and Profit is well-known, but I can't say I use it a lot: https://fsharpforfunandprofit.com/
The same author's (Scott Wlaschin) book is very good: https://pragprog.com/titles/swdddf/domain-modeling-made-func...
As for books, I have always liked:
* Functional Programming Using F# by Hansen and Rischel (might be too simple if you are already comfortable with functional programming and is out of date every now and then with changes to F# that's happened)
* Expert F# 4.0 by Don Syme and others (contains a lot of nice things by the designer of F#
One of the latest books is Stylish F# 6: Crafting Elegant Functional Code for .NET 6 by Kit Eason. I have the first edition but haven't read it.
My personal recommendation is to take the approach of type/domain driven design. That is, I start off every F# module the same:
1. Define my types with discriminated unions, records, type aliases (such as for tuples) or single case discriminated unions. Use classes when necessary but try to prefer the more functional types.
2. Start writing functions against these.
And that's basically it. One thing to recognize with F# is that it mixes OOP rather nicely. Even discriminated unions and records, which are immutable, can have members defined on them, including operator overloading (something F# is pretty good about). They can even implement interfaces and be defined with generic types, which is also nice and powerful.
I have some projects that might of interest, since they're simple enough and illustrate the above process.
https://github.com/bmitc/the-ray-tracer-challenge-fsharp
https://github.com/bmitc/nand2tetris
Lastly, I'd suggest just starting up some projects. You could also take the Programming Languages course on Coursera by Dan Grossman. Part A uses SML, and you could port the examples and homework solutions to F# (I did so when I took the course). I also take books written for other languages and port the code to F#, usually taking a more idiomatic functional style. .NET Interactive notebooks (https://github.com/dotnet/interactive) are a great way to get started. You just need to install the .NET 6 SDK (which gets you F#) and then install the .NET Interactive Notebook extension in VS Code. That's it. There is also the book The Little MLer which gets people comfortable with discriminated unions (sum types), and I used the book and ported the examples to F#. I need to go back and finish that annotation project (https://github.com/bmitc/the-little-fsharper). I'll probably convert the script files to .NET Interactive notebooks if I do.
-
What are you working on? (2022-07)
Here's mine, which is only about halfway through: https://github.com/bmitc/the-ray-tracer-challenge-fsharp
-
Das.Test - an opinionated unit testing library written in F# for F#
I used FsUnit here: https://github.com/bmitc/the-ray-tracer-challenge-fsharp/tree/main/RayTracerChallenge/XUnitTests
-
The joy of building a ray tracer, for fun, in Rust
Yes, the book has both implementations of the required functions (for all the complicated ones you need) and tests all written in pseudocode.
The book is really good. I have a half-finished implementation in F#, and what I find striking is just how close the F# code is to the pseudocode. I have also started an idiomatic port to Racket but have only done the tuples, vector, and point implementations so far. I need to pick these up again.
https://github.com/bmitc/the-ray-tracer-challenge-fsharp
https://github.com/bmitc/the-ray-tracer-challenge-racket
I mean, check this out: https://github.com/bmitc/the-ray-tracer-challenge-fsharp/blo...
I have also worked through pieces of Ray Tracing in One Weekend (what was referenced in this post). They get you going much faster, but the code is written in C++. I found the translation to a functional style was harder (was just using Racket and F#'s mutability features), whereas the way The Ray Tracer Challenge is laid out and specified, I found it much easier to translate to an idiomatic functional style.
- Really great example projects?
- Is F# Tough to Learn?
- What are F#'s advantages?
-
Can anyone suggest any interesting F# projects?
Another project of mine is going through the book The Ray Tracer Challenge with F#. The book is language agnostic and represents the code with pseudocode and presents a test driven approach. My repository is here: https://github.com/bmitc/the-ray-tracer-challenge-fsharp
-
Super simple ray tracer guide after first math semester
I highly recommend the two books:
Ray Tracing in One Weekend: https://www.amazon.com/dp/B01B5AODD8/
The Ray Tracer Challenge: https://www.amazon.com/dp/1680502719/
For the latter, I have made it a pretty good way through the book, implementing a functional (in the programming paradigm sense) version of the ray tracer in F#. It’s actually rather mind boggling how close the F# code and tests are to the psuedocode found in the book.
https://github.com/bmitc/the-ray-tracer-challenge-fsharp
What are some alternatives?
nand2tetris - Original course HDL solutions, F# implementations for the software stack, and VHDL implementations for the hardware stack for the nand2tetris course and The Elements of Computing Systems book.
CardManagement
Bolero - Bolero brings Blazor to F# developers with an easy to use Model-View-Update architecture, HTML combinators, hot reloaded templates, type-safe endpoints, advanced routing and remoting capabilities, and more.
UnionArgParser - A declarative CLI argument parser for F#
equinox - .NET event sourcing library with CosmosDB, DynamoDB, EventStoreDB, message-db, SqlStreamStore and integration test backends. Focused at stream level; see https://github.com/jet/propulsion for cross-stream projections/subscriptions/reactions
MoviesAPI - MoviesAPI is an example of writing a Web API that is sustainable.
the-ray-tracer-challenge-racket - Racket implementations of the ray tracer found in The Ray Tracer Challenge book by Jamis Buck.
minifb - MiniFB is a small cross platform library to create a frame buffer that you can draw pixels in
mal - mal - Make a Lisp