the talent deficit posted:

i think it's only a matter of time before you see clients that effectively just make rpc calls to a backend service. whether this is negotiated via an sdk that uses graphql/rest or just uses something like gRPC or thrift over http2 i think application developers will stop having to care about the details of how their app talks to the server

xtal posted:

If you think the web is good enough I don't even know where to begin with that.

EmmyOk posted:

I'm going through old problems that were a breeze in OOP and taking ages to work out how to even approach them functionally. It's tremendous fun though, I'm being pushed hard to work out how to do things from scratch again.

baka kaba posted:

Get ready, it's gonna ruin Java for you!

If you haven't seen it already you should take a look at F# for fun and profit, it's really comprehensive - and a lot of the examples give you an imperative approach in C#, then the F# equivalent, and then refine it into a more natural F# approach. You can pick up a lot from that kind of thing

EmmyOk posted:

At the moment it's really weird getting my head around using recursion to replace loops. Or I'll see a short code segment and spend a few hours trying to work out how it actually works.

dougdrums posted:

Ok where do I get all of your neat editor things in VS2015? ^^^ those are some hot digraphs

Ochowie posted:

On the topic of f# and monads (this being the FP thread) I stumbled on this tutorial for working with monads in f#.

dougdrums posted:

Snip

baka kaba posted:

Oh yeah, totally forgot about that - it's just the Fira Code font, it has nice ligatures. I use VS Code with the Ionide plugins mostly, it's nice for quick scripting - plus I feel like I'm learning more of the nuts and bolts of working with . NET projects than with VS 2015

dougdrums posted:

Su-Su-Sudoko posted:

It picks out the head, which is a list, and glues that onto the result of recursing on the tail of the list of lists.
You basically end up with

code:

[2; 3; 5;] @ [7; 11; 13] @ [17; 19; 23; 29] @ []

NihilCredo posted:

The code lens (automatic type annotations) in Ionide is amazing. I think it's the first feature it offers that simply can't be found in Visual Studio, and makes it a legit alternative even if you're running on Windows.
I still went back to VS because managing project files by hand (or with Forge's extremely limited commands) is godawful, and the .NET Standard thing has only made targeting even more of a clusterfuck.
I do use VS Code for writing .fsx scripts, though. I made a batteries-included folder that contains FSI.exe and all its required libraries, so I can just give scripts to colleagues without needing them to have anything installed.

dougdrums posted:

All of the digraphs don't show up in VS2015, or I least I couldn't get them to ... in Code they work great though! I've been using Code on my linux laptop, for working on the run or when I'm waiting somewhere. It makes good use of screen space when I don't need a debugger or I am content with using gdb manually. Someone I work with made a more-or-less makefile using a fsx script, including building C libraries. It worked well and I thought it was a pretty good idea.

I find codelens to be annoying in VS (only because it messes up the spacing), but I do find myself hovering my mouse over definitions quite often ...

EmmyOk posted:

code:

let rec concatList l =
    match l with
    | head :: tail -> head @ (concatList tail)
    |[] -> []

EmmyOk posted:

Reading on in the book they are dealing with for loops and sequences but I'm planning to avoid for loops of any description because they're not functional right? And that does help, baka!

Mr Shiny Pants posted:

Of the top of my head, the guy was talking about how you would implement a webserver in Erlang and instead of one process that handles the connections and kicks of threads you would have a process for every connection coming into the server.

Not in particular, no. I was just wondering about general guidelines.

I saw your talk, supervision trees look really nice.

Hughmoris posted:

I realize this is pretty vague but for those who use Haskell, what type of projects have you used it for? I'm making another try at wrapping my head around functional programming with Haskell and looking for inspiration on some projects that people have use the language for. Outside of large, enterprise-size applications.

the talent deficit posted:

i wrote an interpreter for a dumb programming language i invented

Ploft-shell crab posted:

I'm looking at Idris.

Can anyone shed some light on what's going on here:

code:

data Fin : Nat -> Type where
   FZ : Fin (S k)
   FS : Fin k -> Fin (S k)

I think I understand what Fin 5 represents, but what's going on with these constructors??

Ploft-shell crab posted:

I'm looking at Idris.

Can anyone shed some light on what's going on here:

code:

data Fin : Nat -> Type where
   FZ : Fin (S k)
   FS : Fin k -> Fin (S k)

I think I understand what Fin 5 represents, but what's going on with these constructors??

Maluco Marinero posted:

I want to look into erlang or elixir for web development, after having a lot of experience with Python. My main usage will be building stuff bigger than the stuff I use Django for, so essentially I want to figure out the OTP stuff so I can make good use of the hardware I have with at least security in the knowledge that scaling won't be so bad as splitting up a monolith.

What's best in breed in the ecosystem according to people who actually use erlang/elixir? What am I losing if I use elixir? All the frameworks out there market themselves exactly the same way saying they have a great dev experience or fault tolerant or whatever, all products of the language largely, so it's hard to tell where's the best place to invest my time in first.

Ralith posted:

Remember that k : Nat is implicitly universally quantified, because it's lower case. Read the constructors as "for all Nats k, FZ inhabits Fin (S k)" and "for all Nats k, applying FS to a Fin k produces a Fin (S k)"

Asymmetrikon posted:

Fin n represents a finite set of size n (where n is greater than 0) - so like the natural numbers, but bounded by n.

FZ is the zero element, which is a member of all finite sets. You can think of its constructor as "for all natural numbers n, FZ is a member of Fin n iff n is greater than zero".

FS is the successor function; pretty much the same as the Nat successor.

Probably a point of confusion is that FZ and FS can inhabit multiple different types. FZ is a member of Fin 1, Fin 2, and so on. The finite sets are generated inductively, so Fin (S n) contains all of the elements of Fin n, plus FS applied on the greatest element. If we look at the members of each of the Fin instances, we see:

Fin 0 {}
Fin 1 {FZ}
Fin 2 {FZ, FS FZ}
Fin 3 {FZ, FS FZ, FS FS FZ}
...

So (FS FS FS FZ) is a member of Fins 4+.

xtal posted:

Do you notice a similarity between that type and the linked list? It's numbers represented at the type level by recursion. A function like 'length' on link lists could convert this type to an integer.