.Net Foundation On .NET, 26 Nov 2018

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: What's new in F# 4.5

Description

F# 4.5 has been developed entirely via open RFCs (requests for comments), with significant contributions from the community. This release brings together a collection of new features, fixes, and performance enhancements that will surely improve your F# applications.

In this episode, Phillip Carter (@_cartermp) returns to talk to us about many of the new additions in F# 4.5. He also gives us some insight into the RFC process and some of the other decisions that went into creating this release.

[00:43] - Going from F# 4.1 to 4.5
[03:49] - Getting the F# 4.5 bits
[06:20] - New features demo
[25:20] - Making contributions to F#
[29:30] - Compiler relaxations

A

In this episode of the on.net show,, we're going to have phillip carter coming back again to talk about what are some of the new things that are inside of f# 4.5?.

A

Welcome to another episode of the on.net show., my name is celso philip and I have joining me. Again, phillip carter.. What's going on man?, nothing much. just having a good time.. This is like your third time on the show now, right?.

B

Yeah. well, back in the early days of the show, I was on there for a few times.. I had like two hour-long f# ones.

B

Oh wow. yeah., those were a little out of control. wow,. That's a lot of f#.

A

B

So what are you here to talk to us about today?? So I'm here to talk today about f# 4.5.

B

A

Yes., I think, the last time that you're on, we're at f# 4.1.

B

Yes, 4.1,, so we jumped up a few digits.

B

Okay. well, decimal places I guess. decimal points. yeah. so,. It's actually kind of interesting, because the last version was f# 4.1,, but now it's f# 4.5,, and so you might be thinking, well,. What happened in those four places?

B

sure. well, versioning, is something that's always fun,.

B

And everybody always gets it right: every single time.

B

of course. yeah.. So there was some really interesting historical stuff that occurred in the past with f#,, where basically f#, the compiler, depends on the fsharp.core binary,.

B

Which is its core library.? It's got definitions for what an int is,, what void is,.

B

Things like that, and there's been some new additions.

B

And things like that, as time has progressed., but up until,, it was all like just one thing.

B

Until you got to .net framework, 4.0 and so then,, there was a split between .net framework 4.0 world and previous world.

B

And because it was a different runtime,, there was then a different version attached to that binary,, and so you would get version languagemajorversion.languageminorversion.something,.

B

And then there would be an older one., then time, progressed, and then nuget got more and more like a central part of developers, lives with .net.

B

And there was nuget package for fsharp.core, and that version number was not the same as the actual binary, and that got even worse as that nuget package.

B

Then rubbed somewhat semantically,.

B

So that there were to be different minor versions as new things were coming in,, but it would carry a completely different binary..

B

So you had this weird world where at one point I believe we had f# language version, 4.1,.

B

Fsharp.Core binary version 4.4.1.0.

A

And fsharp.core package version 4.3.4.

B

So that made no sense to anybody.

B

right., so the version was a little crazy, there. yeah,, and that was just something where just standard engineering processes of versioning stuff just sort of led down that path, and we were like, "whoa., okay." so,. The only way to reasonably progress forward.

B

And have a version number for everything that was at least sort of aligned about major language. Version, minor language version, was 4.5.

A

B

So now we have f# language version, 4.5,.

B

Fsharp.Core nuget package version 4.5.patch,.

B

And then we have fsharp.core binary version inside of that nuget 4.5. whatever.

B

Sure. so they're not exactly the same numbers, but at least they have the first two digits that are the same, and we intend on keeping it that way from now, on.

A

Sure., it's a little bit more consistent now,. So it's easier for people to see like what pieces go. Together.

B

Yeah, and that's one of those things that starting out as an f# programmer, you never really ran into as much,.

B

But then once you started caring about like, "okay.

B

well,, what binaries do I actually have?.

A

Boom. big confusion.

B

So hopefully, this makes things a lot nicer.

A

Nice., so why don't we talk a little bit about where exactly we can get started and where can we actually get these bits? From?.

B

Yeah. absolutely., so we got a handy-dandy website right, here., the .net homepage and there's an f# page right here.

B

That's just,: you can actually visit it. If you go aka, .ms/fsharphome. it'll. Take you there.

B

So we've got a nice little tagline and most importantly, a big old button that says, "get started with f#.". This will have you download the .net sdk, which has .net core and all that stuff in there.

B

This will give you the latest ones..

B

This will give you f# 4.5 inside of it., so basically,. If you install .net core,, you already have f# actually,, but if you don't have .net core for some reason,, this is definitely the easiest way to get started, because this will work. Obviously across platform, it works inside of visual studio,. It works in vs for mac, vs code,, basically anywhere you want., so not only too do I get.

A

The f# compiler and the f# tools,, but I also get the templates as well, right?.

B

Yeah., so you get some basic templates out of the box with the .net cli. so like in this case,. The little tutorial says: dotnet new console-lang., that's like a little console app, but there's like asp.net core library,.

B

Sorry, asp.net core templates, like library, templates, and then, if you want to use other stuff,, there's a fantastic library called giraph which is for building web services on .net core..

B

It uses asp.net core stuff onto the background.

B

well,. They have their own templates,, and so you can actually use the .net cli to just do. .Net new, well,, there's like a way to install templates from a nuget package,, and so you can just have that.. So there's also a lot of community stuff out there that you can get by using different libraries.

A

Right., so I remember, in the previous episode,, you did come on and talk to us about giraph a little bit.

B

Yeah., you can make sure that we add in that short note,.

A

So everybody can take a look at that episode and see all the good stuff you do with giraph.

B

Yeah. absolutely, and I think giraph recently released version 3.0 since that video., so it's pretty stable. nice.. I recommend trying it out for sure. nice., that's good. yeah.! So that's, basically just how you get started.

B

Now,, you can also use visual studio,, and so I'm just going to move on over there.

B

So if you use visual studio and you get the latest stable version,, so that's 15.8,. I think it's .6.

B

It's sort of the updates version right, now,, that'll hatch., if you download it that'll, be the one you'll get.. This comes with the exact same binaries,.

B

Like the exact same core library, compiler,, as you would get in the .net core sd., actually this will install that same .net, core sdk that you download from site..

B

So if you're on windows, visual studio,, you got everything.

B

good. sounds pretty good.. So why don't we.

A

Talk about some of the new features, right? like what exactly are we getting now in f# 4.5?.

B

Yeah. absolutely. so first of all,.

B

You get some new version numbers., it's not a language feature so to speak.

A

So for those of you who've been.

B

Following c#'s progression and .net,.

B

Core's progression with some of the new stuff involving span,, which is sort of this low-level,. Basically, it's a pointer and offset somewhere in memory.

B

There's all sorts of safety features and efficiencies.

B

Built into the runtime for this construct, and it's been surfaced as language features in newer c#, versions.

B

well,. We did the exact same thing over in f#., so I think the granularity that I chose was about nine features around spans by itself.

A

B

I'm not going to talk about every single one of them., so we introduced the concept of a void pointer in f#,.

B

But that's just sort of something that you'll just kind of use if you're doing more advanced programming, but-., sure., so,, really quickly.

A

Why don't you tell us, what exactly is a span, and what are some of the use? Cases would use that type. Of-?.

B

Yeah. absolutely. so basically, the scenario is,.

B

You want to do high-performance stuff without having to drop down into native code, like with c++ and so,. I mean,.

B

There are a lot of scenarios where you've got to do that anyway.. So it's not something that you should necessarily avoid at all costs,, but there are a lot of people who are saying, "yeah,, but I just want to not allocate a ton and a ton of strings by doing like really basic programming,", and so we sort of said, "okay..

B

Is there a way that you can do this sort of stuff and manage code and sort of have the safety benefits that you get in .net,.

B

But you still get a bit more, that native performance? ".

B

So the way that you accomplish, that is you restrict things that you can actually do with these constructs. got you.. So if you look at this code sample right, here,, you'll notice, there's two things: here.

B

there's this inref and outref construct.

B

An inref right, there,, and, sorry,, not outref., I meant byref.. So all a byref is, it says, represents a managed pointer in f, sharp code, and that's all it is..

B

So this is just a pointer that exists somewhere..

B

So if you've been doing c programming or c++ programming,, you know the pointers., you can do all sorts of wacky stuff with them.

B

that buys you efficiencies,, but it's also very unsafe..

B

So this basically says, well,, you can do a lot less of the wacky stuff,, but you get a lot of the safety..

B

So if we walk through some of this code here,, I just have a really basic function, called print that just takes an inref, event, and then,. It prints it out.

B

But, say,: I want to do something unsafe.

B

Well,, not necessarily unsafe,, but something that you wouldn't expect.. So inref is basically a read-only managed pointer.

B

Say, I want to go, well, I'm going to mutate that to be the value 12.

B

well, that doesn't work.

A

So I get squiggles there saying that this is read only,.

B

So the write is not permitted.. This is the thing because f sharp uses type inference very heavily for things..

B

When you start using these constructs,, we will infer to the inref as much as we can.

B

They basically serve because we are immutable by default with all of our binding., so it would also makes sense for our pointers to be read only by default,, if you're, relying on inference.

A

So, in this case, I specified the type explicitly,.

B

But this is an inref. Is what you're going to see a lot in f sharp code., so you run into that. now,. If you are actually doing something where you're like, yes,, I want to mutate. The value, then,you use a byref.

B

A byref is just like,, it's read-write., so in this case, I could print out the value,.

B

I could set it equal to itself times itself,.

B

And then, print it out again, and do something like that.. So the way that you use inrefs and byrefs varies very slightly..

B

So in this case, I've defined a value called num,, which is initially a value 12.. This is an immutable value.. I can't change this without the code compiling., but I can still actually pass a reference to that, like a pointer to that value to the print function, because print,, it's just a read, only thing.

B

So I'm not actually going to be mutating it., so the way that you actually do that is,, you just use the ampersand keyword, and that just says, take a reference of this, which is, in this case, a pointer..

B

It's the exact same way that you would pass by reference in f sharp,, which coincidentally also uses the byref and inref constructs.

B

we're saying,. Not only is it for pass by reference,.

B

But it's for all this stuff.

B

got it. for the second function,. I can't just do this.

B

say, I delete this.. This is not going to work. type mismatch.

B

Expecting a byref,, but I gave it an inref., I'm basically saying, treat num as an inref, because this is effectively using type inference and saying, well, treat this as what it is.. It is an immutable value,.

B

So we turn it into an inref.

B

So,, what you need to do, is, you need to actually establish something to be mutable upfront,. If you want to pass something in as a byref,.

B

Because that's sort of, okay, this value can change. so then,, I'm going to use the construct that allows you to change things., that's the way that works.

B

then, there's also one thing that I want to call out: here, an actual intentional compiler error..

B

So we also have scoping rules for byrefs..

B

This is something that's entirely new and after our 4.5.

B

So say, I wanted to find this value x. That's a byref., then, inside,. I wanted to find a value y. That's mutable.!.

B

Then,, it doesn't necessarily have to immutable,, but then,. Basically, say, return. The reference of this internally defined value.

B

Well,, that's actually an unsound thing because being able to say, give me a pointer to a thing that I defined in a scope that is now effectively finished.

B

So like this right, here, say,, you were to do something even more dangerous, like let's mutable y.

B

Equals 12 and try to have it escape its scope, like this.

B

Well, it's for the same rules..

B

This is not going to work because it was defined within the scope of this function..

B

So I can't just have this pointer pointing to this thing that is effectively being reinitialized all the time.

B

That's something that'll just lead to crazy, bugs., you're, very likely to end up crashing your application. If you depend on that. it's for some reason. so,, that's why we just make it a compiler error straight off the bat.

B

so,. We restrict your usage of this stuff.

B

But with that restriction, you get certain efficiencies, and you can know that you're not going to completely blow up. If you do that.

A

Right., so I think the compiler now is able to optimize some of these operations now, because it knows exactly, am I mutating this thing or not.

A

then,, like you say, you get some of that safety, some of those safeguards around.. Let me not shoot myself in the foot by doing some crazy.

B

But speaking of things that you can do,, that might still be a bit unexpected.

B

So I got this fun little function called sequenceinator5000. sequenceinator5000.

A

Yeah,, it's a good one.

B

Okay., what does this do?? This has got just an array of numbers,, just some values in it.

A

Then,, I just have a two string.

B

Override inside of this class, that just basically just string dot joins a space in between each of the values.

B

then,. I have a method in here called findlargestsmallerthantarget., so basically,, given an int,, find the largest value, that's still smaller than that integer,, except there's a key difference.

B

you'll notice,. Instead of passing a value that corresponds to,.

B

Hey, I found the index, I'm going to pass the value. That's back to that,, I'm passing a reference to that value,, which is actually a pointer to that space in the underlying number array.

B

So, what's interesting, there is,, if I use it, say,.

B

I set my target to be 16,, I'm actually going to be doing a byref return for this method.

B

so rather than just returning the value, I'm returning the pointer.. I can treat that as a reference that I can then mutate.

B

So let me just run this, just show you why this is interesting.

B

sure. I'll start without debugging here..

B

I think I set the correct one.. It's startup. all right.

B

Cool. so the first one is 1, 3, 7, 15, [inaudible]., but then you notice it's 1,, 3, 7, 30..

B

This is a bit different..

B

The reason why is because I use that same ampersand, right, there,.

B

And then,, I invoke the method and I get the results.

B

then,. I change it to be itself multiplied by two.

B

In this case, I'm not grabbing a value and then just changing that value. Just inside.

B

In this space., where I'm at right, now., I'm actually saying, no, mutate, the thing that's in there..

B

This is a pattern. That's used for unity.

B

And other game programming, and things like that.- that's at least one of the major use cases..

B

So this is something that's c sharp has supported for a bit, and we supported consuming them in f sharp 4.1..

B

But we did not support production of these byref returns up until now.

B

So now, we support both consumption and production.

B

So you can interrupt perfectly., so you can send the thing that a c sharp component may be expecting.. You can do that same manipulating.

B

Pointer stuff with unity programming,, which is pretty cool. right., that's awesome., yeah., so, speaking of perf,, so I'll show you a benchmark of this,.

B

But let me give you a short scenario.

B

So imagine you've got a web server, you're processing a bunch of strings in there,, and you need to do something really basic, like,. I've got some sort of separator.

B

in this case it's a comma,, but it's it doesn't have to be a comma., I'm just doing some type of parsing, right?

B

yeah., I'm trying to pull information out of that- yeah. so,. This is like just a trivial function,, but you do this stuff all the time. Actually, if you're in some high-performance thing, where you're like, no, I know that data's going to exist at this point..

B

I want to extract a little pieces of it and then do something with that. and that portion of extract a little pieces of data.

B

Out may very well be a hot loop in something that you're doing that,. It could actually be a bottleneck., so pretty much idiomatic, f, sharp code.

B

In this case is just, okay, I got a string, find the position of the thing,.

B

In this case,, it's a comma, parse out a value that's, in our case, from zero up until that position like what's the value, that's just next to it right, there, and then what's the next value, and then return a tuple, that's comprised of those both.

B

that's fairly straightforward,. Most people should be pretty happy,, but if you need to do that in a hot loop.

B

Where you got just thousands and thousands,, perhaps millions of strings,, you can start to allocate a whole lot., so you may want to rewrite that..

B

So this is where span of t, and some of the struct, and just by reflect, stuff comes into play.

A

So the way that you write it.

B

Is actually almost identical.

B

so in this case, I'm just going to have a span, and I'm just going to take str,, then I'm going to go asspan in this case.

B

so,. That's a number! That's sitting on string.

B

So, then, I'm basically just going to write this exact same code right here,,.

B

But then, instead of string, str.indexof,.

B

I'll just do span.indexof, and so on.

B

Let me just copy and paste that, save you, my terrible typing there.

B

In this case,, this will be the slice method, rather.

B

Than the substring method. there, we go.

B

You're going to change a lot of expensive.

A

Oh yeah., there we go. yeah. see? compiler, helping me out,.

B

But I didn't even bother to look at it., then one last change,, rather than a regular tuple,.

B

Because regular tuples and f-sharp are reference types,, I'm just going to turn this into a sharp tuple.

B

so,. This is something that actually existed in f, sharp 4.1.

B

prior to f sharp 4.5,. You actually could write code like this,, but the compiler didn't really have a deep understanding of what was going on,, and so we weren't necessarily emitting all the correct stuff. so,. If you were to run this now,.

B

Like I have some code for benchmark.net,, I'm not going to sit you through that,, because it runs a whole bunch of different iterations,, but there's quite a difference. so,. When I ran that actually on my mac,.

B

I didn't even use the parallels and since that I'm sitting in, you'll notice this little table here,.

B

The old version, took almost about four seconds to run on average, and the new one takes about 1.5 seconds to run on average..

B

Oh wow., that's kind of cool., that's kind of cool., so that's faster., but the thing that I really like is, if you look at total allocated, in this case,, I had, I think, 10 million strings.

B

I said, okay, parse out 10 million strings.

B

in this case,. It allocated almost a gigabyte to parse that stuff with the old version, and the new one allocated 76 megs.

A

That's crazy. yeah. >. I find a lot of the parse work. That's been going, on,.

A

Particularly in the .net community, has been around,. How can we efficiently manage strings?.

B

Yes., that seems to be like a huge.

A

Bottleneck for a lot of folks,, and particularly we're doing stuff like the parsing, like with json and xml,, and a lot of these return types,, especially for web servers,. We return a lot of these types of data types and we don't really think about the path that comes in along.

A

We just say, "oh, here's a list of stuff, serialize, this understanding over the wire.". You know what I mean?.

B

Yeah, and that sort of stuff,, just getting your job done, just have some strings, move them. Through, copy stuff, around, allocate new strings., that's totally fine,, but then all of a sudden you're like, "oh, crap..

B

This thing now needs to have a really high load coming into it," and then all of a sudden, all those allocations,. They really start to really hit you over long spans of time, because,. I mean, honestly. The difference for a single run between four seconds versus 1.5 seconds is not like that big of a deal,.

B

But that memory allocation is huge because if this thing is running for like hours at a time or basically just running perpetually, well, each time, you're sort of saying, "oh,, I'm allocating a gig., I'm allocating a gig., allocating a gig," and then the gc eventually has to come in and clean stuff. Up,.

B

And then gc pauses the world and it says, "hey..

B

I got to get rid of stuff," and then you start getting hit with that.. That's where it becomes really nasty to deal without these sort of things like span,.

A

And that's one of the big motivations for.

B

That whole set of stuff- that's in the runtime,.

B

And surfacing that up in the language.

B

cool. yeah. now you can do that all with f sharp, which is pretty great. nice., it's awesome. so,. What are.

A

The new features we have in 4.5?.

B

We got a few other ones,, it's not just asspan.. As I said, I didn't cover everything with the span. Work.

B

there's different representations of pointers, there's the actual way to represent byreflike struct.

B

So I'll just actually just show this really quickly.. You notice. I got some compiler errors?

B

yeah., I'm defining a struct here, and it takes in two spans as inputs, and you're like, "oh., that should just work,, right?"., yeah., well, no. because span is not just a struct, span. Is a byreflike struct., it's something that has some special locks on it..

B

I guess you could say it sort of says,, "no,, no, no. this thing lives on the stack.. This thing is allocated on the stack,. It stays on the stack,, you don't accidentally have it live on the heap somehow.

B

But this struct,, without specifying that it is byreflike,.

B

Gives you no guarantee that you're going to be either on the stack or the heap, you're just going to be allocated how you're allocated.?

B

So in this case,?

B

It's actually very simple,, just sort of add the additional attributes. so span is itself a byreflike struct,.

B

And so one of the rules with these is,, if you want to have it byreflike struct contained with another one,, you can't just stick it inside the class,.

B

You can't just stick it anywhere, you want., it has to be inside of another byreflike struct,, and that constraint is what allows basically the runtime to do things a lot faster than it would be able to do. so,-..

B

So you just annotated it. With, is byreflike?.

B

Yeah., this is just a little attribute. You stick on there., so this does disallow you from doing really weird stuff.

B

So you can't start allocating stuff on the heap inside of the struct anymore..

B

This locks you down and they're saying, "no. you're on the stack,". But if that's something that is of a benefit to your performance-wise,, then this is definitely a good thing.

B

So enough about that stuff, because puff,, it's just boring.

A

Nobody likes that, right? no.. We got.

B

A new keyword which is pretty fun.

A

B

Yeah, we got a new keyword and another type here that I'm going to show at the same time..

B

So people who use f sharp know about pattern, matching it's usually one of their favorite features.. They also know about the option type., some of it or none of it, is basically wherever representing, either. If something can exist or nothing exists.

B

Well,, that's optional, type., it's a reference type, and we wanted to have a struct version of that.

B

So we have it,, it's called valuesome and valuenone..

B

It basically works the exact same way,, it's just it's a struct rather than option, sorry,, rather than a reference type..

B

So if you're in sort of one of those scenarios where a structs is of a benefit to you,, performance-wise or whatever,, then you can use that,.

B

And not like a really big feature,.

B

But just something that people should be able to make some use out. Of., that's right. but,, one of the things that people seem to really love a lot. When this came out, and what's cool is,, this is actually a full community. Contribution, is the new match, bang keyword..

B

So I got this highlighted right, here. now,! This is slightly different than the match keyword..

B

So I'm going to walk through the first one., so this first one, match under tryparseintasync,, because obviously it need to be asynchronous to parse an integer, right?.

A

Right., so I'm just going to try parse and then produce.

B

A valuesome if I got it,, otherwise I produce a valuenone., so this is just okay. match on the value., pretty straight-forward., most f sharp programmers know how to do this. All over the place.. It's usually one of the first things you learn how to do when you're learning, f, sharp in the first place.

B

This is an asynchronous option.

B

This isn't just a value option, that's being returned..

B

This is an async of value option.. This is the thing that's wrapping around it saying no,.

B

This thing exists in an asynchronous context., so to extract the underlying value,. You need to extract effectively out of that context,.

B

And that's something that if you tried to write without the matchmaking keyword today, like say,, I just got rid of that,. This isn't going to work because I was expecting a value option,.

B

But instead, I got an async of value, option.

B

So, this basically just does that unwrapping.

B

Normally, you could write code,, you could you could do something like let being v=tryparseintasync str,.

B

And then, v itself is going to be a value option. Then you could match on v,.

B

But that's just boilerplate., so you just inline, make that call there,.

B

That simplifies a bit of extra code that you need.

B

nice. so,. I want to go back really quickly.

A

So,, you said that this was a community contribution.

A

so,. Can we talk about that really quickly? so,? How does the community go along the routes, of- oh,.

A

Hey,, I think this is a cool feature and I'm guessing f# is open source., so we could put it on github and we create an issue and then we start discussing it. is that-.

B

Yes., so we actually have a full process in place.

B

So we have a repository called language suggestions,.

A

And in the language suggestions, repository,.

B

You basically just file an issue: saying, hey,, I think it'd be cool. If you do this. yes., we have a template. That's like it asks you questions to say, hey,.

B

It summarize what's the thing that you want,: what are the reasons why you want this,? Have you considered if this is a breaking change, things like that to get people to think about the problem? A little bit.

B

then,, there's a discussion and what we'll do is we'll go in, we'll talk through it. if we think it makes sense, we'll mark it as approved and principle,, which is a way of saying,.

B

We think this would make sense to exist in the future. F# language version.

A

Right. then, from that point forward,. It's completely.

B

Open for anybody to say,, oh well,, I can write a spec for this.

B

so,. If you write the spec,, we have an rfc as we call it..

B

We have another rfcs repository where everything is organized..

B

We have passed rfcs for past language versions where.

A

They're all organized in a little folder.

B

Then,, we have just a regular folder called rfcs, where anything, that's an active spec that has not shipped yet exists.. So you can just add a new file there and again,. We have another template, and we say, okay,. We basically track back like what's the suggestion that this write, a spec for.

B

Then, we can write out everything there, like what's the motivation,, what's the summary,? What's the detailed design,, what are some additional things to consider,?

B

What are some alternatives that you may have thought of,?

B

What are some potential drawbacks to doing this feature, things like that.

B

then,, once that's fleshed out in an in-place for merge, it,, we'll say, okay,, the spec is there, and then,. It's up for anybody to implement the actual compiler feature.

B

So in this case, we had an open-source contributor, jon westenberg, who came by, and he said, "yes,. I'd like to do this.. I think this'd be pretty cool.". So the community talked about the matchmaking keyword.

B

they all seem to like it.. Then he said, "all right I'll, write the spec." so,. He wrote the spec., then he said, "okay, well,. I guess I'll write the poll requests." so,. We wrote the pull requests. nice.. We worked with him each of the stages..

B

He was really, really good.. When I say we worked with him,, we barely had to really do much just sort of said..

B

He would ask the question like, "oh hey,. How do I do x?", and we'd say, "okay, just go right, there", and then he'd go right there and then implement it and it was of high-quality. so,. We decided when it was time.

B

To grab the things that we felt would make sense for a f# 4.5, we said, okay,. This is an open poll request that is complete.. Everything seems to work, all the tests. Passed,, we tried it out,. We think we like it,, let's bring it in., so we brought it in and then boom.

B

it's in there and we get to do probably one of my favorite things,.

B

Which is when I write the release, notes to explain like something that came ou in the next visual studio version or something as specifically attribute him as the person who implemented this whole thing.. So that was pretty cool.

B

since then, he's actually implemented other things and submitted to other rfc's,.

B

Other issues, that stuff., so that's how the whole process works,, and that was something that I think is really cool.. It's just end to end from the beginning, all the way until actually shipping..

B

This is a full community thing that we just guided along. Until now, everybody can use it.

B

It's really empowering for your.

A

Community, too, to see, hey,. This is not just something that we talk about doing, like open source,. This is real open-source. yes. you can contribute,, you can make suggestions,.

A

You could be a part of the discussion, and then eventually, you could chip inside of visual studio., yes,, yes, exactly.

B

What's interesting also, is he actually did not use visual studio to implement any of this because he has mac.

A

So he used vs for mac,.

B

But he didn't use just vs for mac.

B

He was using the cli,, he was using-. vs code.

A

-Vs code, that stuff.

B

So,, it was also cool that not only he was a community person,, but this is not someone who is using visual studio for windows, the old associations where it would get with .net and f#..

B

He was fully and this new cross-platform world, doing it all end-to-end, which is really awesome.

A

That's awesome, and this is so great to hear., so I know we're running low on time.. Do you have any other cool little features we could show just before we cut off?.

B

Yes, yes. just one little thing.. I got this little project called relaxation, because I like to relax. relaxation,, I like that. so,. This is just two little-. I guess you could say.

B

The compiler was just a little bit to nitpicky prior to f# 4.5.

B

So in this case, I got basically,.

B

A list of object. so strings are also objects,.

B

So, due to the rules of inheritance,, you can say,, I have a list of objects and then it's comprised of strings..

B

If I wanted to combine that string character with this yield, expression,.

B

I would actually need to explicitly cast object prior to f# 4.5,, which is annoying because logically,.

B

Strings are objects, so it should just work well in f# 4.5,, it just works. You don't have to do. That.

A

You don't have to do that, cast anymore. yes., then another one,.

B

So you'll notice that there's some indentation going on here that might throw you off a little bit..

B

I have this starting bracket here for this array,.

A

Except it actually tad over rather than being right, here.

A

B

That's because in f# 4.1, you had to actually do that., so people would write code that looks like this,, which I think looks totally fine..

B

There's no reason for this not to exist this way,, but the compiler would say, "oh,.

B

You got a bad indentation", and that doesn't make any sense., so in f# 4.5, we just made it so it doesn't do that anymore,, and this is actually something that should help out people who use the fable compiler,, which is an f# to javascript transpiler..

B

It has a way to use f# syntax to model like a dom tree.

B

So, the way that you would syntactically model, that is, you, oftentimes, align stuff vertically, like this,, and so if people would want to do that, and then the compiler would yell at them. so,. That's just a nice little goody for people who were doing especially that stuff..

B

Those are the little relaxations.

B

Of syntax that we have with 4.5.

A

Cool. this was awesome, man.. Thank you so much for coming on the show, man. yes, yes, absolutely.. So this is another episode of on.net show..

A

We just had philip telling us all about the good stuff. That's inside of f# 4.5.