Discover and read the best of Twitter Threads about #fsharp

One actual reason (for me) to use objects in #fsharp is polymorphic recursion in members; it is not available on functions. I wish there was a form of object expressions which immediately introduced a type without a separate interface or abstract type.

Example: one would expect this to work, because the function seemingly accepts any 'a but it doesn’t: let rec printSome (a : Option<‘a>) = match a with | Some a -> printfn a | None -> printSome (Some “Fake Some!”)

So when I really need such a function, I’d like to “wrap” it in a member with as little ceremony as possible. Kind of like Scala’s singleton objects. Now I need to define a boilerplate interface and “inplement” it in an object expression.

Making illegal states unrepresentable without access to at least HKTs and preferrably also to GADTs and type families is so limited that it becomes almost futile. Or becomes very verbose in a similar way to having no polymorphism/“generics”. #fsharp #Haskell #ddd

Here is a type for a customer and address in pseudo-#fsharp syntax: type Customer f = Customer of Name * f<Adress>. Newly registered customer may or may not enter an address: register : ... -> Customer Option. But...

... placing an order requires the address to be known: placeOrder : ... -> Customer<Identity> -> Order. Where type Identity<a> = a.

I write #fsharp and #haskell daily (and #purescript too) and thought of making a micro-blog comparison of the two. Fun facts and maybe new discoveries for the interested, in no particular order. This will be long and probably slow.

Unlike #fsharp, #haskell has no records, only discriminated unions. It does have something called “record syntax” for DUs.

In #fsharp functions cannot be overloaded. In #haskell it is possible through the “type classes” mechanism, conceived specifically for this.

Read 14 tweets

#fsharp Twitter is making fun of default interfaces, as usual somewhat ... uninformed. Imagine you are defining a set of operations on an ADT (abstract data type) where one operation can be implemented in terms of another. Then one of the two can be provided beforehand.

For types which admit more efficient implementation, the default implementation can be provided explicitly. Basic example of related operations: + and *.

Every applicative can be given a default implementation in terms of a monad, same for `map` and `bind` etc. Not that this one is usable in #fsharp with or without default interfaces though, but still a nice example.

Interfaces are not functional, but inherently OO in the sense that there is always an object involved to which you send a message (= call member of the interface). So interfaces are contracts for objects (or values, but this does not help) and not for types. #fsharp

Programmers used to interfaces and not used to type classes rarely think of this example: wouldn’t it be natural and useful to have “empty collection” as part of, say, ICollection<‘t>? That would be a contract for type t itself as opposed to values of t. #fsharp

So static interface members are actually a very exciting feature which makes interfaces more functional and strictly more expressive and therefore useful. #fsharp

Scott Nimrod

@Bizmonger

@ScottWlaschin

Given a 3 week deadline, I just built a mobile app using #fsharp and #xamarinforms for emergency responders.

I applied techniques I learned from @ScottWlaschin 's book, @debasishg 's book, and @IDesign_inc 's book.

The mobile solution is partitioned into two sub-domains in which each layer (UI, Domain, Data Store) relies on their relative specification library. A specification library exposes business terminology as record or choice types and business policies as function types.

I spent the first 2 days domain-modeling.

I then put together a Project Design document that provided three options for how the application would be developed given the time constraints. These options included advantages and disadvantages for each option.

Read 9 tweets

Krzysztof Cieślak

@k_cieslak

I’ve been recently asked why I still use .Net if I hate it so much (concluding based on some of my tweets).

So here’s the point - I LIKE .NET. I think it’s really good technology in many aspects and really great choice for many types of problems.

1/n

I really like some of the stuff MSFT is doing with .Net - F# (😜), editor tooling services as part of compiler design (still concept totally foreign to many languages, especially FP), good improvements of .Net Core, performance magic in ASP .NET and more...

2/n

No one is pointing gun at me when I spend countless hours building OSS stuff on .Net, writing blog posts, or giving talks (especially in the places traditionally not using .Net) and promoting it.

3/n

Read 9 tweets

Bruce Johnston

@bitsforthought

https://twitter.com/jakubjedryszek/status/1171552558181052417

Wow, these results are sobering. In an effort to turn them around, I’m going to attempt a Twitter #monadtutorial. I realize this has probably been done before, but here goes anyway... 1/

https://twitter.com/jakubjedryszek/status/1171552558181052417

This will not be Haskell-focused. Haskell was my first introduction to monads back in 1999, and it just confused the heck out of me. Instead I’ll use examples from #csharp and #fsharp, since they’re what I know best. 2/

First, ignore category theory jargon. Unless you’re doing actual math (or Haskell), “Monad” as a concept is far less important than its practical applications. So let’s start with what monads are good for, before getting into what they are. 3/

Read 28 tweets

“Active pattern-oriented programming” feels like a discipline within DDD on its own. #fsharp

Sort a list of values by a “binary” key, then mix nested, AND and OR (active) patterns with list cons pattern to detect patterns of complex data in the original list.

Sorting is meant to push all potentially interesting values to the start of the list and treat it kind of like a set in pattern matching.