F# Eğitimi: Tam Yığın F# Uygulaması Nasıl Oluşturulur

Son yıllarda, işlevsel programlama, özellikle titiz ve üretken bir paradigma olarak ün kazanmıştır. Programcı topluluklarında yalnızca işlevsel programlama dilleri ilgi görmekle kalmıyor, aynı zamanda birçok büyük şirket de ticari sorunları çözmek için işlevsel programlama dillerini kullanmaya başlıyor.

Örneğin, Walmart, ödeme altyapısı için JVM tabanlı işlevsel bir Lisp lehçesi olan Clojure'u kullanmaya başladı; Büyük bir e-ticaret platformu olan (şu anda Walmart'a ait olan) Jet.com, mikro hizmetlerinin çoğunu oluşturmak için F# kullanıyor; ve tescilli bir ticaret firması olan Jane Street, algoritmalarını oluşturmak için öncelikle OCaml'i kullanır.

Bugün F# programlamayı keşfedeceğiz. F#, esnekliği, güçlü .NET entegrasyonu ve yüksek kaliteli kullanılabilir araçları nedeniyle giderek artan bir şekilde benimsenen işlevsel programlama dillerinden biridir. Bu F# öğreticisinin amaçları doğrultusunda, hem ön uç hem de arka uç için yalnızca F# kullanarak basit bir web sunucusu ve ilgili bir mobil uygulama oluşturacağız.

Neden F# Seçilmeli ve F# Ne İçin Kullanılır?

Bugünkü proje için F# dışında hiçbir şey kullanmayacağız. Tercih ettiğimiz dil olarak F#'ı tercih etmenin birkaç nedeni var:

• .NET entegrasyonu: F#, .NET dünyasının geri kalanıyla çok sıkı bir entegrasyona sahiptir ve bu nedenle çok çeşitli programlama görevlerini çözmek için iyi desteklenen ve kapsamlı bir şekilde belgelenmiş kitaplıklardan oluşan büyük bir ekosisteme hazır erişime sahiptir.
• Kısalık: F#, güçlü tür çıkarım sistemi ve kısa sözdizimi nedeniyle son derece özlüdür. Programlama görevleri genellikle F# kullanılarak C# veya Java'dan çok daha zarif bir şekilde çözülebilir. F# kodu karşılaştırma ile çok basit görünebilir.
• Geliştirici araçları: F#, .NET ekosistemi için en iyi IDE'lerden biri olan güçlü Visual Studio entegrasyonuna sahiptir. Windows olmayan platformlarda çalışanlar için görsel stüdyo kodunda çok sayıda eklenti var. Bu araçlar, F# ile programlamayı son derece üretken hale getirir.

F# kullanmanın yararları hakkında devam edebilirim ama lafı daha fazla uzatmadan konuya girelim!

F# Eğitimimizin Arkasındaki Fikir

Amerika Birleşik Devletleri'nde popüler bir söz vardır: “Bir yerlerde saat beştir” .

Dünyanın bazı bölgelerinde, bir içki veya geleneksel bir fincan çay içmenin sosyal olarak kabul edilebilir olduğu en erken saat 17:00'dir.

Bugün bu konsepte dayalı bir uygulama geliştireceğiz. Herhangi bir zamanda, çeşitli zaman dilimlerinde arama yapan, saatin beşte nerede olduğunu bulan ve bu bilgiyi kullanıcıya sağlayan bir uygulama oluşturacağız.

Arka Uç

Web Sunucusunu Ayarlama

Saat dilimi arama işlevini gerçekleştiren arka uç hizmetini yaparak başlayacağız. Bir JSON API'si oluşturmak için Suave.IO kullanacağız.

Suave.IO, basit web uygulamalarının çok hızlı bir şekilde kodlanmasına izin veren hafif bir web sunucusuna sahip sezgisel bir web çerçevesidir.

Başlamak için Visual Studio'ya gidin ve yeni bir F# Konsol Uygulaması projesi başlatın. Bu seçeneği kullanamıyorsanız, F# işlevselliğini Visual Studio Installer ile yüklemeniz gerekebilir. Projeye “FivePM” adını verin. Uygulamanız oluşturulduktan sonra şöyle bir şey görmelisiniz:

 [<EntryPoint>] let main argv = printfn "%A" argv 0 // return an integer exit code

Bu, argümanı yazdıran ve durum kodu 0 ile çıkan çok basit bir başlangıç ​​kodu parçasıdır. Yazdır ifadesini değiştirmekten ve kodun çeşitli işlevlerini denemekten çekinmeyin. "%A" biçimlendirici, girdiğiniz türün dize temsilini yazdıran özel bir biçimlendiricidir, bu nedenle tam sayıları, kayan noktaları ve hatta karmaşık türleri yazdırmaktan çekinmeyin. Temel sözdizimi konusunda rahat olduğunuzda, Suave'i kurmanın zamanı geldi.

Suave'i kurmanın en kolay yolu NuGet paket yöneticisidir. Proje -> NuGet paketlerini yönet seçeneğine gidin ve gözat sekmesine tıklayın. Suave'i arayın ve yükle'yi tıklayın. Yüklemek için paketleri kabul ettiğinizde, hazır olmalısınız! Şimdi program.fs ekranınıza dönün ve sunucuyu oluşturmaya başlamaya hazırız.

Suave'i kullanmaya başlamak için önce paketi içe aktarmamız gerekecek. Programınızın en üstüne aşağıdaki ifadeleri yazın:

 open Suave open Suave.Operators open Suave.Filters open Suave.Successful

Bu, temel bir web sunucusu oluşturmak için gereken temel paketleri içe aktaracaktır. Şimdi ana koddaki kodu, basit bir uygulamayı tanımlayan ve 8080 numaralı bağlantı noktasında sunan aşağıdaki kodla değiştirin:

 [<EntryPoint>] let main argv = // Define the port where you want to serve. We'll hardcode this for now. let port = 8080 // create an app config with the port let cfg = { defaultConfig with bindings = [ HttpBinding.createSimple HTTP "0.0.0.0" port]} // We'll define a single GET route at the / endpoint that returns "Hello World" let app = choose [ GET >=> choose [ path "/" >=> request (fun _ -> OK "Hello World!")] ] // Now we start the server startWebServer cfg app 0

F# sözdizimine veya Suave'nin rota işleyicileri tanımlama yöntemine aşina olmasanız bile, kod çok basit görünmelidir, kod oldukça okunabilir olmalıdır. Esasen, web uygulaması 200 statüsü ve “Merhaba Dünya!” ile geri döner. "/" yolunda bir GET isteği ile vurulduğunda dize. Devam edin ve uygulamayı çalıştırın (Visual Studio'da F5) ve localhost:8080'e gidin ve “Merhaba Dünya!” görmelisiniz. tarayıcı pencerenizde.

Sunucu Kodunu Yeniden Düzenleme

Artık bir web sunucumuz var! Ne yazık ki, pek bir şey yapmıyor - bu yüzden ona biraz işlevsellik verelim! İlk olarak, web sunucusu işlevselliğini başka bir yere taşıyalım, böylece web sunucusu hakkında endişelenmeden bazı işlevler oluşturalım (daha sonra web sunucusuna bağlayacağız). Ayrı bir işlevi şu şekilde tanımlayın:

 // We'll use argv later :) let runWebServer argv = // Define the port where you want to serve. We'll hardcode this for now. let port = 8080 // create an app config with the port let cfg = { defaultConfig with bindings = [ HttpBinding.createSimple HTTP "0.0.0.0" port]} // We'll define a single GET route at the / endpoint that returns "Hello World" let app = choose [ GET >=> choose [ path "/" >=> request (fun _ -> OK "Hello World!")] ] // Now we start the server startWebServer cfg app

Şimdi ana işlevi aşağıdaki gibi değiştirin ve doğru yaptığımızdan emin olun.

 [<EntryPoint>] let main argv = runWebServer argv 0

F5'e basın ve "Merhaba Dünya!" sunucu eskisi gibi çalışmalıdır.

Saat Dilimlerini Alma

Şimdi saatin beş olduğu zaman dilimini belirleyen işlevselliği oluşturalım. Tüm zaman dilimlerini yinelemek ve 17:00'ye en yakın saat dilimini belirlemek için bazı kodlar yazmak istiyoruz.

Ayrıca, 17:00'ye çok yakın olan ancak biraz önce olan (örneğin 16:58) bir zaman dilimini gerçekten döndürmek istemiyoruz, çünkü bu gösterinin amaçları doğrultusunda, öncül saatin 5'ten önce olamayacağıdır. :00 pm, ancak yakın.

Saat dilimlerinin bir listesini alarak başlayalım. F#'da bu, C# ile çok iyi entegre olduğu için çok kolaydır. En üste "açık Sistem" ekleyin ve F# uygulamanızı şu şekilde değiştirin:

 [<EntryPoint>] let main argv = // This gets all the time zones into a List-like object let tzs = TimeZoneInfo.GetSystemTimeZones() // Now we iterate through the list and print out the names of the timezones for tz in tzs do printfn "%s" tz.DisplayName 0

Uygulamayı çalıştırın ve konsolunuzda tüm zaman dilimlerinin, uzaklıklarının ve görünen adlarının bir listesini görmelisiniz.

Özel Tip Oluşturma ve Kullanma

Artık saat dilimlerinin listesine sahip olduğumuza göre, bunları bizim için daha yararlı olan özel bir veri türüne dönüştürebiliriz, UTC farkı, yerel saat, yerel saatle 17:00'den ne kadar uzakta olduğu gibi bilgileri içeren bir şey. , vb. Bu amaçla, ana işlevinizin hemen üzerinde özel bir tür tanımlayalım:

 type TZInfo = {tzName: string; minDiff: float; localTime: string; utcOffset: float}

Şimdi, son adımdan aldığımız saat dilimi bilgilerini bu TZInfo nesnelerinin bir listesine dönüştürebiliriz. Ana işlevinizi şu şekilde değiştirin:

 [<EntryPoint>] let main argv = // This gets all the time zones into a List-like object let tzs = TimeZoneInfo.GetSystemTimeZones() // List comprehension + type inference allows us to easily perform conversions let tzList = [ for tz in tzs do // convert the current time to the local time zone let localTz = TimeZoneInfo.ConvertTime(DateTime.Now, tz) // Get the datetime object if it was 5:00pm let fivePM = DateTime(localTz.Year, localTz.Month, localTz.Day, 17, 0, 0) // Get the difference between now local time and 5:00pm local time. let minDifference = (localTz - fivePM).TotalMinutes yield { tzName=tz.StandardName; minDiff=minDifference; localTime=localTz.ToString("hh:mm tt"); utcOffset=tz.BaseUtcOffset.TotalHours; } ] printfn "%A" tzList.Head 0

Ve Dateline Standard saati için tzInfo nesnesinin ekranınıza yazdırıldığını görmelisiniz.

Sıralama ve Filtreleme ve Borulama, Oh My!

Artık bu tzInfo nesnelerinin bir listesine sahip olduğumuza göre, 1) 17:00'den sonra ve 2) 1'deki saat dilimlerinin 17:00'ye en yakın olduğu zaman dilimini bulmak için bu nesneleri filtreleyebilir ve sıralayabiliriz. Ana işlevinizi şu şekilde değiştirin:

 [<EntryPoint>] let main argv = // This gets all the time zones into a List-like object let tzs = TimeZoneInfo.GetSystemTimeZones() // List comprehension + type inference allows us to easily perform conversions let tzList = [ for tz in tzs do // convert the current time to the local time zone let localTz = TimeZoneInfo.ConvertTime(DateTime.Now, tz) // Get the datetime object if it was 5:00pm let fivePM = DateTime(localTz.Year, localTz.Month, localTz.Day, 17, 0, 0) // Get the difference between now local time and 5:00pm local time. let minDifference = (localTz - fivePM).TotalMinutes yield { tzName=tz.StandardName; minDiff=minDifference; localTime=localTz.ToString("hh:mm tt"); utcOffset=tz.BaseUtcOffset.TotalHours; } ] // We use the pipe operator to chain functiona calls together let closest = tzList // filter so that we only get tz after 5pm |> List.filter (fun (i:TZInfo) -> i.minDiff >= 0.0) // sort by minDiff |> List.sortBy (fun (i:TZInfo) -> i.minDiff) // Get the first item |> List.head printfn "%A" closest

Ve şimdi aradığımız saat dilimine sahip olmalıyız.

Saat Dilimi Alıcısını Kendi İşlevine Göre Yeniden Düzenleme

Şimdi kodu kendi işlevine göre yeniden düzenleyelim, böylece daha sonra kullanabiliriz. Bir işlevi şu şekilde tanımlayın:

 // the function takes uint as input, and we represent that as "()" let getClosest () = // This gets all the time zones into a List-like object let tzs = TimeZoneInfo.GetSystemTimeZones() // List comprehension + type inference allows us to easily perform conversions let tzList = [ for tz in tzs do // convert the current time to the local time zone let localTz = TimeZoneInfo.ConvertTime(DateTime.Now, tz) // Get the datetime object if it was 5:00pm let fivePM = DateTime(localTz.Year, localTz.Month, localTz.Day, 17, 0, 0) // Get the difference between now local time and 5:00pm local time. let minDifference = (localTz - fivePM).TotalMinutes yield { tzName=tz.StandardName; minDiff=minDifference; localTime=localTz.ToString("hh:mm tt"); utcOffset=tz.BaseUtcOffset.TotalHours; } ] // We use the pipe operator to chain function calls together tzList // filter so that we only get tz after 5pm |> List.filter (fun (i:TZInfo) -> i.minDiff >= 0.0) // sort by minDiff |> List.sortBy (fun (i:TZInfo) -> i.minDiff) // Get the first item |> List.head And our main function can just be: [<EntryPoint>] let main argv = printfn "%A" <| getClosest() 0

Kodu çalıştırın ve öncekiyle aynı çıktıyı görmelisiniz.

Dönüş Verilerini Kodlayan JSON

Artık saat dilimi verilerini alabildiğimize göre, bilgileri JSON'a dönüştürebilir ve uygulamamız üzerinden sunabiliriz. NewtonSoft'un JSON.NET paketi sayesinde bu oldukça basittir. NuGet paket yöneticinize dönün ve Newtonsoft.Json'ı bulun ve paketi kurun. Şimdi Program.fs'ye dönün ve ana işlevimizde küçük bir değişiklik yapın:

 [<EntryPoint>] let main argv = printfn "%s" <| JsonConvert.SerializeObject(getClosest()) 0

Kodu şimdi çalıştırın ve TZInfo nesnesi yerine konsolunuza yazdırılan JSON'u görmelisiniz.

Saat Dilimi Bilgisini JSON API'sine Bağlama

Bunu JSON API'mize bağlamak çok basittir. runWebServer işlevinizde aşağıdaki değişiklikleri yapmanız yeterlidir:

 // We'll use argv later :) let runWebServer argv = // Define the port where you want to serve. We'll hardcode this for now. let port = 8080 // create an app config with the port let cfg = { defaultConfig with bindings = [ HttpBinding.createSimple HTTP "0.0.0.0" port]} // We'll define a single GET route at the / endpoint that returns "Hello World" let app = choose [ GET >=> choose [ // We are getting the closest time zone, converting it to JSON, then setting the MimeType path "/" >=> request (fun _ -> OK <| JsonConvert.SerializeObject(getClosest())) >=> setMimeType "application/json; charset=utf-8" ] ] // Now we start the server startWebServer cfg app

Uygulamayı çalıştırın ve localhost:8080'e gidin. Tarayıcı pencerenizde JSON'u görmelisiniz.

Sunucuyu Dağıtma

Artık JSON API sunucusuna sahip olduğumuza göre, onu internet üzerinden erişilebilir olacak şekilde dağıtabiliriz. Bu uygulamayı dağıtmanın en kolay yollarından biri, yönetilen bir IIS hizmeti olarak anlaşılabilecek Microsoft Azure'un Uygulama Hizmeti'dir. Azure Uygulama hizmetine dağıtmak için https://portal.azure.com'a gidin ve Uygulama Hizmeti'ne gidin. Yeni bir uygulama oluşturun ve portalınızdaki dağıtım merkezine gidin. Portal, ilk seferinizse biraz bunaltıcı olabilir, bu nedenle sorun yaşarsanız, App Service'i kullanmak için orada bulunan birçok öğreticiden birine başvurduğunuzdan emin olun.

Dağıtım için çeşitli seçenekler görmelisiniz. İstediğinizi kullanabilirsiniz, ancak basitlik adına FTP seçeneğini kullanabiliriz.

Uygulama hizmeti, uygulamanızı nasıl çalıştıracağınızı öğrenmek için uygulamanızın kökünde bir web.config dosyası arar. Web sunucumuz önemli bir konsol uygulaması olduğundan, uygulamayı yayınlayabilir ve HttpPlatformHandler kullanarak IIS sunucusuyla entegre edebiliriz. Visual Studio'da projenize bir XML dosyası ekleyin ve onu web.config olarak adlandırın. Aşağıdaki XML ile doldurun:

 <?xml version="1.0" encoding="UTF-8"?> <configuration> <system.webServer> <handlers> <remove name="httpplatformhandler" /> <add name="httpplatformhandler" path="*" verb="*" modules="httpPlatformHandler" resourceType="Unspecified"/> </handlers> <httpPlatform stdoutLogEnabled="true" stdoutLogFile="suave.log" startupTimeLimit="20" processPath=".\publish\FivePM.exe" arguments="%HTTP_PLATFORM_PORT%"/> </system.webServer> </configuration>

Dağıtım merkezinden alınan kimlik bilgilerini kullanarak FTP sunucusuna bağlanın (FTP seçeneğine tıklamanız gerekir). web.config dosyasını uygulama hizmeti FTP sitenizin wwwroot klasörüne taşıyın.

Şimdi uygulamamızı oluşturmak ve yayınlamak istiyoruz, ancak yapmadan önce sunucu kodunda küçük bir değişiklik yapmamız gerekiyor. runServer işlevinize gidin ve ilk 3 satırı aşağıdaki şekilde değiştirin:

 let runWebServer (argv:string[]) = // Define the port where you want to serve. We'll hardcode this for now. let port = if argv.Length = 0 then 8080 else (int argv.[0])

Bu, uygulamanın iletilen argümana bakmasına ve portun 8080'e sabit kodlanmış olması yerine ilk argümanı port numarası olarak kullanmasına izin verir. Web yapılandırmasında, ilk argüman olarak %HTTP_PLATFORM_PORT%'u iletiriz, bu yüzden biz ayarlanmalıdır.

Uygulamayı yayın modunda oluşturun, uygulamayı yayınlayın ve yayınlanan klasörü wwwroot'a kopyalayın. Uygulamayı yeniden başlatın ve *.azurewebsites.net sitesinde JSON API sonucunu görmelisiniz.

Artık uygulamamız devreye alındı!

Ön Uç

Artık sunucuyu dağıttığımıza göre, bir ön uç oluşturabiliriz. Front end için Xamarin ve F# kullanarak bir Android uygulaması oluşturacağız. Bu yığın, arka uç ortamımız gibi, Visual Studio ile derin entegrasyona sahiptir. Tabii ki, F# ekosistemi birkaç ön uç geliştirme seçeneğini destekliyor (WebSharper, Fable/Elmish, Xamarin.iOS, DotLiquid vb.), ancak kısaca olsun, bu gönderi için yalnızca Xamarin.Android kullanarak geliştireceğiz ve ayrılacağız. onları gelecekteki gönderiler için.

Kurulum

Android uygulamasını kurmak için yeni bir proje başlatın ve Xamarin Android seçeneğini seçin. Android geliştirme araçlarının kurulu olduğundan emin olun. Proje kurulduktan sonra ana kod dosyanızda bunun gibi bir şey görmelisiniz.

 [<Activity (Label = "FivePMFinder", MainLauncher = true, Icon = "@mipmap/icon")>] type MainActivity () = inherit Activity () let mutable count:int = 1 override this.OnCreate (bundle) = base.OnCreate (bundle) // Set our view from the "main" layout resource this.SetContentView (Resources.Layout.Main) // Get our button from the layout resource, and attach an event to it let button = this.FindViewById<Button>(Resources.Id.myButton) button.Click.Add (fun args -> button.Text <- sprintf "%d clicks!" count count <- count + 1 )

Bu, F# Android Xamarin için başlangıç ​​kodudur. Kod şu anda bir düğmeye kaç kez tıklandığını takip ediyor ve mevcut sayım değerini gösteriyor. Öykünücüyü başlatmak için F5'e basarak ve uygulamayı hata ayıklama modunda başlatarak çalıştığını görebilirsiniz.

UI Bileşenleri Ekleme

Bazı UI bileşenleri ekleyelim ve daha kullanışlı hale getirelim. Kaynak/düzenleri açın ve Main.axml'e gidin.

Ana faaliyet düzeninin görsel bir temsilini görmelisiniz. Öğelere tıklayarak çeşitli UI öğelerini düzenleyebilirsiniz. Araç kutusuna gidip eklemek istediğiniz öğeyi seçerek öğe ekleyebilirsiniz. Düğmeyi yeniden adlandırın ve düğmenin altına bir textView ekleyin. AXML'nizin XML temsili şuna benzer görünmelidir:

 <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:andro android:orientation="vertical" android:layout_width="match_parent" android:layout_height="match_parent"> <Button android: android:layout_width="match_parent" android:layout_height="wrap_content" android:text="@string/fivePM" /> <TextView android:text="" android:textAppearance="?android:attr/textAppearanceMedium" android:layout_width="match_parent" android:layout_height="wrap_content" android: /> </LinearLayout>

AXML, dizeler kaynak dosyasına başvuruda bulunur, bu nedenle resource/values/strings.xml dosyanızı açın ve aşağıdaki değişiklikleri yapın:

 <?xml version="1.0" encoding="utf-8"?> <resources> <string name="fivePM">It\'s 5PM Somewhere!</string> <string name="app_name">5PM Finder</string> </resources>

Şimdi ön uç AXML'yi oluşturduk. Şimdi onu bir koda bağlayalım. MainActivity.fs'ye gidin ve onCreate işlevinizde aşağıdaki değişiklikleri yapın:

 base.OnCreate (bundle) // Set our view from the "main" layout resource this.SetContentView (Resources.Layout.Main) // Get our button from the layout resource, and attach an event to it let button = this.FindViewById<Button>(Resources.Id.myButton) let txtView = this.FindViewById<TextView>(Resources.Id.textView1); button.Click.Add (fun args -> let webClient = new WebClient() txtView.Text <- webClient.DownloadString("https://fivepm.azurewebsites.net/") )

Fivepm.azurewebsites.net'i kendi JSON API dağıtımınızın URL'si ile değiştirin. Uygulamayı çalıştırın ve öykünücüdeki düğmeye tıklayın. Birazdan, API sonucunuzla birlikte JSON API dönüşünü görmelisiniz.

JSON'u ayrıştırma

Neredeyse geldik! Şu anda uygulamamız ham JSON'u görüntülüyor ve oldukça okunamıyor. O halde bir sonraki adım, JSON'u ayrıştırmak ve daha insan tarafından okunabilir bir dize çıktısı almaktır. JSON'u ayrıştırmak için sunucudan Newtonsoft.JSON kitaplığını kullanabiliriz.

NuGet paket yöneticinize gidin ve Newtonsoft.JSON'u arayın. MainActivity.fs dosyasını kurun ve geri dönün. “open Newtonsoft.Json” ekleyerek içe aktarın.

Şimdi projeye TZInfo tipini ekleyin. TZInfo'yu sunucudan yeniden kullanabiliriz, ancak aslında yalnızca iki alana ihtiyacımız olduğundan, burada özel bir tür tanımlayabiliriz:

 type TZInfo = { tzName:string localTime: string }

Ana işlevin üzerine tür tanımını ekleyin ve şimdi ana işlevi şu şekilde değiştirin:

 button.Click.Add (fun args -> let webClient = new WebClient() let tzi = JsonConvert.DeserializeObject<TZInfo>(webClient.DownloadString("https://fivepm.azurewebsites.net/")) txtView.Text <- sprintf "It's (about) 5PM in the\n\n%s Timezone! \n\nSpecifically, it is %s there" tzi.tzName tzi.localTime )

Şimdi JSON API sonucu, TZInfo nesnesinde seri durumdan çıkarılır ve bir dize oluşturmak için kullanılır. Uygulamayı çalıştırın ve düğmesine tıklayın. Ekranda biçimlendirilmiş dizenin açıldığını görmelisiniz.

Bu uygulama çok basit ve belki de rafine edilmemiş olsa da, F# JSON API'sini tüketen, verileri dönüştüren ve kullanıcıya görüntüleyen bir mobil uygulama oluşturduk. Ve hepsini F# ile yaptık. Çeşitli kontrollerle oynamaktan çekinmeyin ve tasarımı iyileştirip iyileştiremeyeceğinizi görün.

Ve işte bizde! Basit bir F# mobil uygulaması ve bir F# JSON API'si ve kullanıcıya saatin beşi nerede olduğunu söyler.

Toplama

Bugün, hem F# dilinin etkileyiciliğini hem de F# ekosisteminin gücünü gösteren, yalnızca F# kullanarak basit bir Web API'si ve basit bir Android uygulaması oluşturma sürecini inceledik. Ancak, F# geliştirmenin yüzeyini zar zor çizdik, bu yüzden bugün tartıştıklarımızı geliştirmek için birkaç yazı daha yazacağım. Ek olarak, umarım bu gönderi size kendi F# uygulamalarınızı oluşturmanız için ilham vermiştir!

Bu eğitim için kullandığımız kodu GitHub'da bulabilirsiniz.