fsharp / tryfsharp Goto Github PK

Currently, the REPL shows 4.0 is in use.

• Steps to reproduce:
  visit https://try.fsharp.org/
  and just run the default sample

• Unexpcted behaviour:
  printfn displaying resut of 3rd sample function claims to be displaying result of 2nd function, instead of 3rd
  "printfn "The result of applying the 2nd sample function to (6.5 + 4.5) is %f" result3"

• Fix:
  replace "2nd" to "3rd"

• Note: on https://docs.microsoft.com/en-us/dotnet/fsharp/tour it is properly displayed.

Looks like TryFSharp uses some older version of F# (noticed by certain new .NET 6.0 methods not being available). Not sure what version, since the following snippet fails to run:

printfn "%A" System.Environment.Version  // throws error: FABLE: Cannot resolve System.Environment.get_Version

It should be noted that the context-sensitive help just works, it recognizes Environment.Version just fine and shows its members.

PS, System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription doesn't work either, since the Interop dll isn't available (afaict).

Hi authors, some people prefer light theme and it's also consistent with the F# website. Can a switch be added to the UI? Thanks!

The following code fails to compile with FABLE: Cannot resolve Microsoft.FSharp.Collections.Array2DModule.Initialize

let s = Array2D.init 3 3 (fun x y -> x + y)
printfn "%A" s

I'm looking at potentially adding integration with the fssnip website. The old silverlight tryfsharp website was capable of loading code from hyperlinks, i.e. using the uri

http://www.tryfsharp.org/Create?codeUrl=http://fssnip.net/raw/7XZ

would result in the particular snippet contents being loaded. Does the current website have such a capability? On quick inspection I see that you can load snippets using a base64 encoded value via the code parameter, but couldn't find anything similar to the above.

cc @tpetricek

hi there,

I am trying to open the website on iPad (yah, I am teaching my kid to learn fsharp on iPad :) ), but it show only available on desktop.

Just wondering if ok to support iPad? I think ipad is good enough to use it?

Thanks

1. In particular, I'm looking for information about how Try F# persists changes.

From experiment, it appears to have persisted some of my changes, but not others.

2. Also, what is the purpose of the GitHub token input and how do I use it?

3. In case I accidentally delete stuff, maybe there could be a reset button to restore the original content.

4. Maybe the last link in the F# Basics section should be a blank page for experimentation (with just something like module Prototyping; open System; printfn "Hello, world!").

The following code contains an infinite loop in it:

open System

type Ops = Add | Sub | Mul | Div | And | Or | Eor | Bic | Lsl | Lsr | Asr | Ror | Ldc of int
         | Dup | Drop | Swap | Over | Ld8 | St8 | Ld16 | St16 | Ld32 | St32 | Se8 | Se16
         | For of Exp | Next | If of Exp*Exp | Func of string*Exp | Ldl of string | Stl of string
and Exp = Ops list

type Sym = Var of int32 | Fun of Exp

let symbols = Map.empty

let isNumber (x:string) = fst (Int32.TryParse(x))


let getOps = function
    | "+" -> Add
    | "-" -> Sub
    | "*" -> Mul
    | "/" -> Div
    | "and" -> And
    | "or" -> Or
    | "eor" -> Eor
    | "bic" -> Bic
    | "lsl" -> Lsl
    | "lsr" -> Lsr
    | "asr" -> Asr
    | "ror" -> Ror
    | "dup" -> Dup
    | "drop" -> Drop
    | "swap" -> Swap
    | "over" -> Over
    | "ld8" -> Ld8
    | "st8" -> St8
    | "ld16" -> Ld16
    | "st16" -> St16
    | "ld32" -> Ld32
    | "st32" -> St32
    | "for" -> For []
    | "next" -> Next
    | x when isNumber x -> Ldc (int x)
    | x -> failwithf "Unknown word %A" x

let exec = function
    | (Add,x::y::xs) -> (x+y)::xs
    | (Sub,x::y::xs) -> (y-x)::xs
    | (Mul,x::y::xs) -> (x*y)::xs
    | (Div,x::y::xs) -> (y/x)::xs
    | (Ldc x,xs)     -> x::xs
    | (_,[]) -> failwith "Empty stack"
    | x      -> failwithf "Unknown Op %A" x

let infix = function
    | (Add,x::y::xs) -> ("("+x+" + "+y+")")::xs
    | (Sub,x::y::xs) -> ("("+y+" - "+x+")")::xs
    | (Mul,x::y::xs) -> ("("+x+" * "+y+")")::xs
    | (Div,x::y::xs) -> ("("+y+" / "+x+")")::xs
    | (Ldc x,xs)     -> (string x)::xs
    | (_,[]) -> failwith "Empty stack"
    | x      -> failwithf "Unknown Op %A" x

let run f = Array.fold (fun xs op -> f (op,xs)) []

//let source = "2 3 + 1 - 2 /"
let source = "1 4 for dup + next + -"
let code = source.Split() |> Array.filter ((<>)"") |> Array.map getOps

printfn "Source:  %A" source
printfn "Code:    %A" code

let rec combFor xs bb ys depth =
    match xs with
    | [] -> if bb <> [] then printfn "ERROR: bb not empty %A" bb
            (xs,[],List.rev (bb@ys))
    | Next::xs when depth = 0 -> printfn "ERROR: No For!"
                                 failwith ""
    | Next::xs when depth = 1 -> (xs,[],List.rev (bb@ys))//(xs,List.rev bb,ys)
    //| Next::xs when depth > 0 -> combFor xs bb ys (depth - 1)
    //| For [] :: xs -> combFor xs bb (For []::ys) (depth + 1)
    | For [] :: xs   -> let (xs,bb,ys) = combFor xs bb ys (depth + 1)
                        combFor xs [] (For bb :: ys) (depth + 1)
    | x::xs when depth > 0 -> combFor xs (x::bb) ys depth
    | x::xs -> combFor (x::xs) bb ys depth

let c = List.ofArray code
printfn "Code:    %A" c
let d = combFor c [] [] 0 
printfn "CFor:    %A" d

//printfn "Infix:   %A" (run infix code)
//let result = run exec code
//printfn "Result = %A" (List.rev result)

It's a lot, but this will run infinitely on a local machine as a console app.

In the browser, this will freeze the page until your browser eventually asks to quit. We should put a limit on execution time and stop executing code, then notify the user about that.

F# has introduced collection[idx] syntax for a while now so we don't have to write collection.[idx]
https://try.fsharp.org/#?code=DYUwLgBCAmCWYH04GcwEMB2BjEEAUyAXBKgE6wYDmAlPmMWRTRMRZALwCwAUBHxKEikQWAQHsxAB3wBbVhjC08GeYpYQ2ELr367YAMxIBtGRAC0EAIwBdLRDBGM5q7bAALEBh66f-YBOk8UwtLJScQ6m9fKGBkECjo-ksIAGp8PH8pCFNlZ1DaAB8APmyKfEzA4KtaDEKSmTKMgNk8sNbqSO4EjUNkADoAGU9KdzsABnsPJzBB4fdukGADe1mqUfYICfdPElWRtwXY3ArdobW3FbP9nhvuGHgkWFRMHAgAIlAMN-eZL4hiiCScgKfRON4AUlgbyAA&html=DwCwLgtgNgfAsAKAAQqaApgQwCb2ag4CdMTJcMABwFp0BHAVwEsA3AXgCIBhAewDsw6AdQAqAT0roOSAMb9BAzoIAeYAPThoAbhkhMAJwDOJNgzAAzagA4OeQhqy5EhAEY9sYu6mBq3HvD6asEA&css=Q

I'm guessing that the system is running an old .NET version.

By experiment, I determined that it supports anonymous record types and therefor must be using F# 4.6.

Could we display the version in the About section?

I would like to use the Fable Compiler to JS from a webpage, just like the REPL does.
Is there a CDN where the code can be downloaded from and an API that shows how to do this?

i Think try F# first sample code should be much simpler, e.g. compare it with rust

https://try.fsharp.org/

https://play.rust-lang.org/?version=stable&mode=debug&edition=2021

we should reduce the information overload and not confuse developers wanting to try F# the first time, also removing accidental complexity of modules, comments and so on, i propose to just have this as first F# program

printfn "hello world"

showing up when opening try F# online

I'm working on my own fork of tryFSharp for my personal site - fsharpnotes.net

I've updated the global.json to using .NET 6 and otherwise haven't done anything special. When I run

fake run build.fsx -t "WatchApp"

I get a path error that (by the eye, at least) should resolve. In fact there are multiple references to the path, which in and of itself is a bit odd. Can anyone weigh in on why this is happening? Is there something I missed along the way - beyond paket restore/build ? Thanks!

I'm what you'd consider as an old developer with astigmatism. The current dark theme is making it impossible for me to use TryFSharp. Support for a light theme would be great for people like me.

Not sure whether or not this is a true bug or not, i.e. maybe it's caused by how date and time are dealt with in browsers, but it does lead to differences in how code works in local FSI vs online FSI.

Example code

open System

let x = DateTime.Now
let y = x.ToUniversalTime()
x.Equals y |> printfn "%A"   // should be false
x = y |> printfn "%A"        // should be false
printfn "%A" x               // should be X hours before/after UTC
printfn "%A" y               // should be UTC

Expected output

If you run this, it should output the following (which is what you'll see when running it locally in FSI, except that in UK the times may actually be equal, anywhere else they should be different):

false
false
2/18/2022 6:37:54 PM
2/18/2022 5:37:54 PM

Actual output on https://try.fsharp.org/

However, it outputs this, note specifically the differences in how the %A outputs the time (which may be due to system wide settings on the machine, so not that big a deal), and, most importantly, that ToUniversalTime() did not change the time to UTC, instead the time variable remained unchanged.

true
true
Fri Feb 18 2022 17:09:41 GMT+0100 (Central European Standard Time)
Fri Feb 18 2022 17:09:41 GMT+0100 (Central European Standard Time)

Upgrade to dotnet tool manifest for fake (and paket, if paket is needed), NET6+ (or NET8), Fake, Vite, ditch octokit and nuget for dotnet publish?

I tried to test build another branch now but doesn't seem possible atm, it seems this repo needs a general upgrade in tooling, maybe webpack could be ditched in favour of vite or perla (simpler to setup?) @AngelMunoz

https://github.com/AngelMunoz/Perla.

On the left-hand side, there are two buttons, an arrow and a cercle:

So far I have not been able to figure out how they are different. I initially assumed the arrow would just execute the code currently selected, and the circle would execute the whole script, but this does not seem to be the case.

In that frame:

• Would it be possible to add tooltips on the buttons to clarify what they do?
• Would it be possible to run only the selected code with the triangle? I find the ability to just edit-and-run small pieces of code in a script very helpful in exploring / understanding what is happening.