Fsharpplus: Examples for the Haskell compability

[ShalokShalom]

Currently, there is no example in the tutorial for the compatibility with Haskell.

[wallymathieu]

There are the following samples:

• Haskell.fsx
• Learn You a Haskell.fsx

[wallymathieu]

So perhaps having links to these files would help?

[ShalokShalom]

Yep.

[gusty]

By pure causality, yesterday I almost copy the sample files to the docs for the Haskell Compatibility. In the end I decided that I would want to review the code and that will take me some time (which yesterday I didn't had). So let's discuss a bit how to organize this samples in the docs.

As I said yesterday in another discussion, I see an overlap between the samples and the docs, since the docs also contain sample and my guess is that we should move all the samples to the doc. Again this is not just copy-paste, it will require adding some explanations to the sample code.

[ShalokShalom]

By pure causality, I almost suggested to actually copy the sample files and was then concerned that this is too much code for this overview. IMHO, a more generic and simple example is suitable.

[wallymathieu]

Operation | F#+ / F# | F#+ Haskell Compatibility | Haskell
-- | -- | -- | --
List.append | @ |   | ++
  | << |   | .
  | <| | $ | $
  | = | == | ==
  | <> | =/ | =/
flip | /> |   | />
apply function to value |   |   |   |  
Functor |   |   |  
map | or <<| |   | <$> or fmap
same as map but arguments interchanged | |>> |   |  
  |   |   |  
Monoid |   |   |  
monoid zero element | getZero() | mempty | mempty
append | ++ or plus | mappend | mappend
  |   |   |  
Applicative functors |   |   |  
apply (combine) | <> |   | <>
Sequence actions, discarding the value of the first argument. | > |   | *>
Sequence actions, discarding the value of the second argument. | < |   | <*
A variant of <*> with the arguments reversed. | <> |   | <>
Lift a value. | result |   | pure
  |   |   |  
Alternative |   |   |  
alternatives: binary operation | <|> |   | <|>
  |   |   |  
Monad |   |   |  
Bind Sequentially compose two actions, passing any value produced by the first as an argument to the second. | >>= |   | >>=
Same as >>=, but with the arguments interchanged. | =<< |   | =<<

[wallymathieu]

?

[wallymathieu]

Then we could perhaps write what can and cannot be done in f# compared to Haskell

[gusty]

@wallymathieu @ShalokShalom feel free to send a PR regarding this, whoever takes the initiative (including myself) just send a message first to avoid duplicate efforts.

My feeling is that we should add that table and regarding the sample files there are actually two files. One is too short, the other one is too long.

The long one, is in the Samples From FsControl folder, which at the same time came from an old exploratory project, originally in google code but now it's being imported to github by some devs, see this import and also this other import, with the translation table used at that time.

Now regarding the Learn you a Haskell file, that was an exercise @vstastny did to learn about the typeclassy stuff here, following the original haskell tutorial, and he gently contributed back to this repo. But note that it's not using the Haskell compatibility, because the idea I think, was to apply the same concepts in F#. So I think it worths adding to the doc, but maybe not in the compatibility (although it might be linked). One thing is syntax and another is abstractions.

[ShalokShalom]

I adore this table.

Then we could perhaps write what can and cannot be done in f# compared to Haskell

Yes, absolutely.

[wallymathieu]

The easiest way to get the table into the docs could be to use github wiki ? Then we could start collaborate on it as well.

[wallymathieu]

Since it does not contain any code examples, it's perhaps not so much a good fit for literate style of programming with fsx, or what's your thougts @gusty ?

[gusty]

The easiest way to get the table into the docs could be to use github wiki ?

I don't get it, what's complicated? You can put it directly in the docs, they support markdown directly AFAIK.

[wallymathieu]

It doesn't support the same markdown syntax. It's a minor thing: you need to transform the table to the dialect of markdown that fsharp formatting supports.

[gusty]

Shame, but moving that out of the docs for a technical limitation seems hacky,
Is there any other way? Something like linking to an external site, as I did for the PlantUML diagram?

[gusty]

It's a minor thing: you need to transform the table to the dialect of markdown that fsharp formatting supports.

Actually this might be the easiest solution. What do you think?

[wallymathieu]

Indeed.

[wallymathieu]

The question is mostly what kind of markdown tables fsharp formatting supports?

[gusty]

https://github.com/fsprojects/FSharp.Formatting/issues/7 and see the linked examples.

[wallymathieu]

Nice!

[ShalokShalom]

Very nice to see, that something such (comparable) trivial gets immediately implemented, while the whole range of the .NET world is still in chaos for such things: https://github.com/dotnet/docs/issues/3446

[wallymathieu]

https://gist.github.com/wallymathieu/19c74f784652f18ae3111056b8403f82

[wallymathieu]

So perhaps someone wants to do a small pull request :wink:

[gusty]

Cool !
I found some inaccuracies, here's the corrected version

Also I noticed some issues.

• Why don't we use (/=) directly? I don't remember if there was an issue, it was many years ago, maybe the F# parser at that time rejected it.

• (++) should be redefined in the Haskell compatibility. I probably forgot to add it.

[ShalokShalom]

OK, i did some changes to this, lets see how they appeal you:

https://gist.github.com/ShalokShalom/11cf9b1943d36ac51939e83bb0fced84

[ShalokShalom]

Some questions:

• $ seems to have another function as <|

• I suggest creating an issue for each operator, which is unported.
  We can then link to this specific issue from our comparison table.

• Some operators still seem to be unnamed yet: What is the purpose?

[wallymathieu]

I've started using <| sort of the same way I use it in Haskell. Since I'm not very deep into it, it's kind of helpful to have something where it's explained.

[gusty]

Not all operators are representable in F#, we can create issues, but the right place to create them will be in the F# compiler project, because there's nothing we can do about it here.

Regarding $ it's a bit for completeness there, but actually the main purpose of the operator which is to avoid parens, it's defeated since it doesn't have the same associativity as in Haskell. Again, there's nothing we can do about it.

Some operators still seem to be unnamed yet: What is the purpose?

Which one, for example?

I've started using <| sort of the s ...

Yes, I use it from time to time, but it also has not the same associativity, so for piping expressions it doesn't work, it's better to do the F# way, I mean reverse the pipe and write with the |> in those cases.

[wallymathieu]

Mmm, indeed. What is your thoughts about the Ocaml way of doing things? More module oriented instead of type class oriented.

[gusty]

I don't have any experience in OCaml, but it seems to be more module oriented.
AFAIK they use their "functor" feature, which is not the same as the functor abstraction, it's rather a parametrizable module and they don't have typeclasses, but I read somewhere that both techniques are equivalent.

[ShalokShalom]

OCaml is very module oriented since they allow higher-order polymorphism by higher-order modules and yes, you can implement type classes as such ones.

Ah, I got now that I can use <| in order to substitute the $ in Standard F-Sharp.

Which one, for example?

=, <| and <> are without description currently and apply function to a value is without operators.

If there are no equivalents on one side or the other, can we mention it by something like not available
Otherwise is it questionable, if the list is either incomplete or the operator missing.

Some other questions:

pure' is correct? Since I do not find it in the source code.

And if binary operation is available in both F-Sharp and Haskell, why implement one in F-Sharp Plus?
Do they work differently?

[wallymathieu]

https://github.com/gusty/FSharpPlus/blob/master/src/FSharpPlus/Compatibility.fs#L94

[ShalokShalom]

Oh, then Github's search does probably crash with `

Thanks a lot

[wallymathieu]

apply function to a value </ or |> has gotten dropped

[ShalokShalom]

So we can remove it?

[ShalokShalom]

Or mention not available

[wallymathieu]

It's very common in f# code, so if it's not available in Haskell then I would find it useful have that fact in the table.

[wallymathieu]

I don't remember why I added

[ShalokShalom]

See now: https://gist.github.com/ShalokShalom/11cf9b1943d36ac51939e83bb0fced84

So, how can I see the specific result of this table?
How does it look like in real life?
Since I like to adjust the visual appearance.

I hope its fine, that I actually named this project?

F#+ Haskell Compatibility burst the width of the column, so I think this can make it leaner and also give the project some identity. :)

[gusty]

apply function to a value

Yes, the definitions are 3 rows above.

And if binary operation is available in both F-Sharp and Haskell, why implement one in F-Sharp Plus?

Do they work differently?
Not 100% sure what do you mean.
Regarding to <|> it's simply the same operator in Haskell and FSharpPlus and also in other languages, like purescript, Idris if I'm not wrong.

I don't remember why I added

That's confusing, probably it was added by me in the original project. The thing is that in Haskell you can partially apply an operator on both sides, well I found out that by using those operators you achieve more or less the same effect but at the cost of ending up with combination of operators. Here's an example:

let f x = fun n -> n - x

in Haskell you can write it:

let f x = (- x)

here you can write:

let f x = (-)/> x

But in fact the idea of these operators is to be able to transform a function in an operator:

let sum x y = x + y

let a = x </sum/> y

[gusty]

@ShalokShalom you can start adding it to the docs, then after running Build or just building the docs you'll see how FSharp Formatting renders that table.

[ShalokShalom]

Oh, I see. I thought initially, this table is just to point out the compatibility layer itself.
So, in that case, a huge load of operators is missing?
What will we include and what not?

[ShalokShalom]

But in fact the idea of these operators is to be able to transform a function in an operator:

let sum x y = x + y

let a = x </sum/> y

I think we should point this out on its own. Otherwise, the whole sense would get gone.

[gusty]

Definitely.

[gusty]

What should get included and what not?

I would say, let's get it done with the basic stuff, as we have it for example.
The goal of the Haskell compatibility module is to facilitate translating code from Haskell, including running on-off examples, but normally if you translate something that later will become more important we should remove the Haskell compatibility. A good example of this, is the recent @wallymathieu work with Validations, see for example that inflexion point happening here

[ShalokShalom]

if you translate something that later will become more important we should remove the Haskell compatibility

So, a Haskell compatibility source-to-source converter onto F-Sharp would be reasonable?

To do this automaticly?

[gusty]

It will never be possible to fully emulate Haskell, specially because of the lazyness and the different type system. Still, my experience is that Haskell.Compatibility helps to run Haskell examples or to do the initial steps to port code coming from Haskell.

Still, human touch will always be required.

[ShalokShalom]

I mean Haskell Compatibility into native F-Sharp (Plus)

[gusty]

Oh, I see what you mean. I guess it makes sense, at least what we can do is to provide a brief guideline of what are the steps to take, and which decisions have to be made.

[ShalokShalom]

Yes, since this seems to be a simple find-and-replace, this might be a nice project for me as a newbie. :)

[gusty]

Go ahead if want to try it on your own, experiment a bit with it, then we can decide to keep it as a separate project/snippet or to include it in this lib.

[ShalokShalom]

The current upload looks like we could use another file extension, in order to achieve another syntax highlight?

I see that the table looks quite similar to here, is there a specific reason to use such one?
Is this purely to cooperate without any document editor?

[gusty]

I think it's because it was in code formatting.
But I just tried to remove the code and it's completely broken now.
I don't know what's wrong or what's the expected format, will keep trying.

[ShalokShalom]

Do you consider that this is an issue in F-Sharp Formatting itself?

Well, I guess they can help, so maybe an issue there would be sane?

[gusty]

Do you consider that this is an issue in F-Sharp Formatting itself?

Yes, definitely.

Well, I guess they can help, so maybe an issue there would be sane?

I think opened some issues there and they never came back. But please go ahead.

It seems to be working, the table is being generated but the style is missing. The tables reference a style header even and odd but they are not in .css they provide.

I'll keep looking ...

[gusty]

See for example this search https://github.com/fsprojects/FSharp.Formatting/search?utf8=%E2%9C%93&q=odd&type=

They generate that style, but they don't provide it.

Alternatively if someone knows of some nice styles for these tables please include it in our template file: https://github.com/gusty/FSharpPlus/blob/master/docsrc/tools/templates/template.cshtml

[wallymathieu]

that kind of styling of tables is kind of common, so they probably assume that you will bring your own

[gusty]

Well, apart from that there definitely bugs in their parser, see below:

Generating 'D:\temp\989e43d\docsrc\tools\..\content/abstractions.html' Generating 
'D:\temp\989e43d\docsrc\tools\..\content/applicative-functors.html' Generating 
'D:\temp\989e43d\docsrc\tools\..\content/computation-expressions.html' Generating 
'D:\temp\989e43d\docsrc\tools\..\content/generic-doc.html' Generating 'D:\temp\989e43d\docsrc\tools\..\content/haskell-compatibility.html' FsiEvaluationException: Error: 
System.Exception: Unexpectedly stopped!     [""; " |>>"; ""]       at 
[email protected](String message) in 
c:\Tomas\Public\tpetricek\FSharp.Formatting\src\FSharp.Markdown\MarkdownParser.fs:line 756
at [email protected](Unit unitVar) in c:\Tomas\Public\tpetricek\FSharp.Formatting\src\FSharp.Markdown\MarkdownParser.fs:line 756       
at [email protected](Unit unitVar0)       
at Microsoft.FSharp.Collections.SeqModule.ToList[T](IEnumerable`1 source)      
at Microsoft.FSharp.Primitives.Basics.List.mapToFreshConsTail[a,b](FSharpList`1 cons, FSharpFunc`2 f, FSharpList`1 x)      
at Microsoft.FSharp.Primitives.Basics.List.map[T,TResult](FSharpFunc`2 mapping, FSharpList`1 x)        
at Microsoft.FSharp.Collections.ListModule.Map[T,TResult](FSharpFunc`2 mapping, FSharpList`1 list)     at Microsoft.FSharp.Primitives.Basics.List.mapToFreshConsTail[a,b](FSharpList`1 cons, FSharpFunc`2 f, FSharpList`1 x)       
at Microsoft.FSharp.Primitives.Basics.List.map[T,TResult](FSharpFunc`2 mapping, FSharpList`1 x)        
at [email protected](Unit unitVar) in c:\Tomas\Public\tpetricek\FSharp.Formatting\src\FSharp.Markdown\MarkdownParser.fs:line 690       
at [email protected](Unit unitVar0)       
at [email protected](Unit unitVar0)       
at [email protected](Unit unitVar0)      
at Microsoft.FSharp.Collections.Genera[e-mail](Unit unitVar0)       
at Microsoft.FSharp.Collections.Generator.appG[a](Generator`1 g)

Had to leave the table as code for now.

If someone want to report these errors, please go ahead !

[ShalokShalom]

Sounds like this is pretty much unmaintained?

Is there any alternative to FSharp Format?

[gusty]

No that I know. But it's just a matter of making some noise and either they come back or eventually a new maintainer will be assigned.

Coming back to the very beginning of our conversation, I would consider now the alternative @wallymathieu proposed initially: linking to a normal .md file, embedding it, or make it open in a new window.

[ShalokShalom]

And what speaks against something like this?

[gusty]

That looks very nice, but the problem is that it's hard to maintain.
I mean, you have to generate it each time you update it.
I had the same problem with the plantUml diagram, but finally I found a solution that generates it in the build process.
Anyway, we can also create it in plain html, right?

[wallymathieu]

Indeed, plain html is simple enough 👍 so could be an alternative

[ShalokShalom]

Generate it?

Its a simple screenshot. I edit the parts that I want, go fullscreen and: Screenie :D

[ShalokShalom]

Does this list change so often that a difference of some seconds makes such a huge difference?

[wallymathieu]

Well, you always want someone who is totally unfamiliar with things to be able to edit it

[ShalokShalom]

Yeah, a spreadsheet?

[wallymathieu]

So can we create an issue on formatting? We can ping forki if we are willing to help out on any fsproject stuff.

[wallymathieu]

https://github.com/fsprojects/FSharp.Formatting/issues/456

[ShalokShalom]

So, I think I got a great idea, while it might sound a little bit crazy first.
Its completely optional, so you can do both.
I just realised, that Wikipedia shows such tables in a neat way and I think its nice to link from the top page
( http://gusty.github.io/FSharpPlus/ ) to the Wikipedia article.
In general is Wikipedia a great place for such docs, IMHO since a lot of people will inform themself their about fsharp. So if we create a own, dedicated F-Sharp Plus page, which reflects the major aspects of the homepage can we link to it from the F-Sharp article. So, many people will get aware about the project in general and we can store the table there. Plus, such documentation in the form of examples are quite common in programming article on Wikipedia. See here: https://en.wikipedia.org/wiki/Map_(higher-order_function)

[gusty]

I haven't seen a wikipedia article about a specific library, but if you wan't to try adding one, go ahead.
It might be the first :)

[ShalokShalom]

Well, F-Sharp Plus is more as a library ;)

Its a couple of libraries in one ;)

So you can say its a library collection?

[gusty]

It's true that is not a specific library, it's rather a base library, or even as @wallymathieu said, a language extension.

[ShalokShalom]

Language extension sounds awesome, this is also what I thought first.

[ShalokShalom]

We are also able to put it simply in Github?

https://github.com/ipfs/ipfs/blob/master/IMPLEMENTATION_STATUS.md

[gusty]

Yes, that's the option discussed at the beginning, Linking to an md file.

[ShalokShalom]

Apples and Lemons convinced me. I think we all should code in fruits. Also an option for applicative operators. ;)

[ShalokShalom]

Do you think its sane to name this library Hashkell or H#? 😄

[gusty]

No way, that's not the goal of this library.

This is meant to be a base library for F#, the fact that it uses some concepts from Haskell doesn't convert it in a Haskell emulator and that's not the purpose of this project.

Moreover, I was thinking many times in removing the Haskell compatibility and make it a separate project, but the idea of the Compatibility namespace is to have other languages.

Taking ideas from Haskell is common practice today, and you see it in most frameworks, libraries and languages.

[wallymathieu]

Having it as a separate library sounds nice 👍 It also promotes the idea of F#+ base library status (if you have an eco system of libraries with distinct and sensible responsibilities).

[ShalokShalom]

@gusty

I was thinking many times in removing the Haskell compatibility and make it a separate project, but the idea of the Compatibility namespace is to have other languages.

Is there any chance to get OCaml support in?

[gusty]

@wallymathieu True, that was also my conclusion. Actually there is in fsprojects already a Compatibility project which has a Haskell module but there's almost nothing there.

That might be a good destination for the Haskell Compatibility. Feel free to open an issue to further discuss it.

@ShalokShalom regarding OCaml in that library there is some support already.

[ShalokShalom]

Oh, fine ^-^

[voronoipotato]

On the emoji for indicators I've always felt that I should be able to make emoji as operators, but F# throws up every time I try. By contrast I can use them as variables or types without issue.

type ``🌰`` = string
let ``🍏`` = true
let ``🍅`` = false

//the best workaround I can think of is to use off menu butterfly operator
let ``🍔`` a b = a * b
3 |>``🍔``<| 4
//or ....

type System.Int32 with
  member x.``🙅`` n = x * n

3 .``🙅`` 5

WHEN WILL THE CHAINS THAT BIND OUR OPERATORS BE LOOSED.

[ShalokShalom]

This way >> https://github.com/fsharp/fslang-design :D
Perl users will scream from feelings of jealousy and fascination ;)

[voronoipotato]

I've already tried, Don won't hear my pleas of mercy.

https://fslang.uservoice.com/forums/245727-f-language/suggestions/5688398-allow-unicode-symbols-to-be-used-as-operators

[wallymathieu]

I'm closing this issue since Haskell compatibility has been ported to FSharp.Compatibility : https://github.com/fsprojects/FSharp.Compatibility/pull/11 including the table.