Scott Theleman - Understanding F# Workflows
F# Workflows are a powerful and elegant tool for solving many real-world problems, though they can be rather daunting at first. We'll survey some ways in which Workflows in the standard F# libraries are used for common development tasks, then dig into detail on how they work. We'll then build a workflow that provides a validation framework that can be used for parsing or other tasks.
Scott Theleman is a Software Developer with over 10 years professional design and development experience in both small startup and mid-sized corporate/Enterprise environments on applications ranging from desktop GUIs to website/web applications to server side and middleware work. He has also been Technical Lead on several government contracts.
He has worked on a diverse range of projects including a network discovery and topology product, a Learning Management System, Enterprise Service Oriented Architecture components for a large and complex search service, and atmospheric and weather sciences applications.
Language experience includes C++, Perl, Java and C#. He is currently working as a consultant on various projects including an atmospheric sciences product which will make extensive use of the latest Microsoft technologies including F# and WPF.
ZIO: Powerful and Principled Functional Programming in ScalaWiem Zine Elabidine
This is an introduction of purely functional programming type safe abstractions that provide a variety of features for building asynchronous and concurrent applications data structures built on ZIO.
You'll learn by examples about the power of functional programming to solve the hard problems of software development in a principled, without compromises.
statement in python conditional statement.For more presentation please contact us on raginijain0208@gmail.com.
You get new presentation every Sunday at 10 AM.
Learn more about Python by click on this given below link
Python Introduction- https://www.slideshare.net/RaginiJain21/final-presentation-on-python
Basic concept of Python -https://www.slideshare.net/RaginiJain21/python-second-ppt
Python Datatypes - https://www.slideshare.net/RaginiJain21/data-types-in-python-248466302
Python Library & Module - https://www.slideshare.net/RaginiJain21/python-libraries-and-modules
Basic Python Programs- https://www.slideshare.net/RaginiJain21/basic-python-programs
Python Media Libarary - https://www.slideshare.net/RaginiJain21/python-media-library
ZIO: Powerful and Principled Functional Programming in ScalaWiem Zine Elabidine
This is an introduction of purely functional programming type safe abstractions that provide a variety of features for building asynchronous and concurrent applications data structures built on ZIO.
You'll learn by examples about the power of functional programming to solve the hard problems of software development in a principled, without compromises.
statement in python conditional statement.For more presentation please contact us on raginijain0208@gmail.com.
You get new presentation every Sunday at 10 AM.
Learn more about Python by click on this given below link
Python Introduction- https://www.slideshare.net/RaginiJain21/final-presentation-on-python
Basic concept of Python -https://www.slideshare.net/RaginiJain21/python-second-ppt
Python Datatypes - https://www.slideshare.net/RaginiJain21/data-types-in-python-248466302
Python Library & Module - https://www.slideshare.net/RaginiJain21/python-libraries-and-modules
Basic Python Programs- https://www.slideshare.net/RaginiJain21/basic-python-programs
Python Media Libarary - https://www.slideshare.net/RaginiJain21/python-media-library
How To Manage API Request with AXIOS on a React Native AppAndolasoft Inc
Making an API request is as simple as passing a configuration object to Axios or invoking the appropriate method with the necessary arguments. Read More: https://www.andolasoft.com/blog/how-to-manage-api-request-with-axios-on-react-native-app.html
Practical and conceptual overview of Javascript prototype paradigm, how to use prototypes, how do they work, and how do they differ from classes, and why there are no real classes in Javascript.
A storage class defines the scope (visibility) and life time of variables and/or functions within a C++ Program. There are following storage classes which can be used in a C++ Program
auto
register
static
extern
Blazing Fast, Pure Effects without Monads — LambdaConf 2018John De Goes
Effect monads like IO are the way functional programmers interact with the real world. Yet, monadic effects in programming languages like Scala often perform poorly compared to their Haskell counterparts—as much as 10x slower in some benchmarks. In this presentation, John A. De Goes, author of the Scalaz 8 effect system, dredges up an old paper to cast new light on the question of how to model effects, and comes to the surprising conclusion that in Scala, monads may not be the fastest way to model purely functional effects. Join John as he shows a new model of effects that offers performance improvements without sacrificing the wonderful purity that functional programmers rely on to reason about their software.
How To Manage API Request with AXIOS on a React Native AppAndolasoft Inc
Making an API request is as simple as passing a configuration object to Axios or invoking the appropriate method with the necessary arguments. Read More: https://www.andolasoft.com/blog/how-to-manage-api-request-with-axios-on-react-native-app.html
Practical and conceptual overview of Javascript prototype paradigm, how to use prototypes, how do they work, and how do they differ from classes, and why there are no real classes in Javascript.
A storage class defines the scope (visibility) and life time of variables and/or functions within a C++ Program. There are following storage classes which can be used in a C++ Program
auto
register
static
extern
Blazing Fast, Pure Effects without Monads — LambdaConf 2018John De Goes
Effect monads like IO are the way functional programmers interact with the real world. Yet, monadic effects in programming languages like Scala often perform poorly compared to their Haskell counterparts—as much as 10x slower in some benchmarks. In this presentation, John A. De Goes, author of the Scalaz 8 effect system, dredges up an old paper to cast new light on the question of how to model effects, and comes to the surprising conclusion that in Scala, monads may not be the fastest way to model purely functional effects. Join John as he shows a new model of effects that offers performance improvements without sacrificing the wonderful purity that functional programmers rely on to reason about their software.
It exists.
It takes time.
It requires culture and discipline.
Unit and function testing is what takes the least time.
Hours writing an automated test is time invested, not time wasted!
[4DEV] Bartosz Sokół - Functional developer in object oriented world - how F#...PROIDEA
Object-oriented programming languages have been here for decades, helping millions of developers to deliver (sort of) working software. Still, after many years, we still struggle with things like nulls and exceptions, which make our applications crash in most unexpected ways. So I have taken a challenge - can you use object-oriented language (C#) and write code in a way that those issues are almost gone? I will show how to leverage lessons learned from functional programming to make our applications more bulletproof - and fun to write as well!
In programming languages, a closure (also lexical closure or function closure) is a function or reference to a function together with a referencing environment as a block
learn how to program with python
from scratch to be an expert
use the link in the first slide to get the full course
here is the link if you want : https://oke.io/JdxdUl
the link of the documentation : https://oke.io/J6DeY3
link to download python : https://oke.io/BENgRLR2
How can we implement concepts of Lambda Calculus and Category Theory in C# and F#:
- Lambda Calculus: The importance of expressions to build a robust and reasonable program flow
- Category Theory: How to apply functional concepts like functors, applicatives or monads to deal wit
Ethnobotany and Ethnopharmacology:
Ethnobotany in herbal drug evaluation,
Impact of Ethnobotany in traditional medicine,
New development in herbals,
Bio-prospecting tools for drug discovery,
Role of Ethnopharmacology in drug evaluation,
Reverse Pharmacology.
Palestine last event orientationfvgnh .pptxRaedMohamed3
An EFL lesson about the current events in Palestine. It is intended to be for intermediate students who wish to increase their listening skills through a short lesson in power point.
How to Make a Field invisible in Odoo 17Celine George
It is possible to hide or invisible some fields in odoo. Commonly using “invisible” attribute in the field definition to invisible the fields. This slide will show how to make a field invisible in odoo 17.
Model Attribute Check Company Auto PropertyCeline George
In Odoo, the multi-company feature allows you to manage multiple companies within a single Odoo database instance. Each company can have its own configurations while still sharing common resources such as products, customers, and suppliers.
Students, digital devices and success - Andreas Schleicher - 27 May 2024..pptxEduSkills OECD
Andreas Schleicher presents at the OECD webinar ‘Digital devices in schools: detrimental distraction or secret to success?’ on 27 May 2024. The presentation was based on findings from PISA 2022 results and the webinar helped launch the PISA in Focus ‘Managing screen time: How to protect and equip students against distraction’ https://www.oecd-ilibrary.org/education/managing-screen-time_7c225af4-en and the OECD Education Policy Perspective ‘Students, digital devices and success’ can be found here - https://oe.cd/il/5yV
This is a presentation by Dada Robert in a Your Skill Boost masterclass organised by the Excellence Foundation for South Sudan (EFSS) on Saturday, the 25th and Sunday, the 26th of May 2024.
He discussed the concept of quality improvement, emphasizing its applicability to various aspects of life, including personal, project, and program improvements. He defined quality as doing the right thing at the right time in the right way to achieve the best possible results and discussed the concept of the "gap" between what we know and what we do, and how this gap represents the areas we need to improve. He explained the scientific approach to quality improvement, which involves systematic performance analysis, testing and learning, and implementing change ideas. He also highlighted the importance of client focus and a team approach to quality improvement.
Synthetic Fiber Construction in lab .pptxPavel ( NSTU)
Synthetic fiber production is a fascinating and complex field that blends chemistry, engineering, and environmental science. By understanding these aspects, students can gain a comprehensive view of synthetic fiber production, its impact on society and the environment, and the potential for future innovations. Synthetic fibers play a crucial role in modern society, impacting various aspects of daily life, industry, and the environment. ynthetic fibers are integral to modern life, offering a range of benefits from cost-effectiveness and versatility to innovative applications and performance characteristics. While they pose environmental challenges, ongoing research and development aim to create more sustainable and eco-friendly alternatives. Understanding the importance of synthetic fibers helps in appreciating their role in the economy, industry, and daily life, while also emphasizing the need for sustainable practices and innovation.
The Art Pastor's Guide to Sabbath | Steve ThomasonSteve Thomason
What is the purpose of the Sabbath Law in the Torah. It is interesting to compare how the context of the law shifts from Exodus to Deuteronomy. Who gets to rest, and why?
How to Split Bills in the Odoo 17 POS ModuleCeline George
Bills have a main role in point of sale procedure. It will help to track sales, handling payments and giving receipts to customers. Bill splitting also has an important role in POS. For example, If some friends come together for dinner and if they want to divide the bill then it is possible by POS bill splitting. This slide will show how to split bills in odoo 17 POS.
Operation “Blue Star” is the only event in the history of Independent India where the state went into war with its own people. Even after about 40 years it is not clear if it was culmination of states anger over people of the region, a political game of power or start of dictatorial chapter in the democratic setup.
The people of Punjab felt alienated from main stream due to denial of their just demands during a long democratic struggle since independence. As it happen all over the word, it led to militant struggle with great loss of lives of military, police and civilian personnel. Killing of Indira Gandhi and massacre of innocent Sikhs in Delhi and other India cities was also associated with this movement.
Cambridge International AS A Level Biology Coursebook - EBook (MaryFosbery J...
Understanding F# Workflows
1. Understanding F# Workflows New England F# User’s Group Presentation (fsug.org) August 2, 2010 Scott Theleman
2. Overview F# Workflows – closely related to Monads in Haskell and other languages – are a powerful and elegant tool for solving many real-world problems, though they can be rather daunting at first. We'll survey some ways in which Workflows in the standard F# libraries are used for common development tasks, then dig into detail on how they work. Finally we’ll build a workflow that provides a validation framework that can be used for parsing or other tasks.
3. Intro to Monads A “Monad” is generally a set of interrelated constructs. At the least, it usually consists of: A “Monadic Type” A bind function (sometimes the (>>=) operator is used) A return function “When the designers of F# talked with the designers of Haskell about this, they agreed that the word monad is obscure and sounds a little daunting and that using other names might be wise” — Expert F# 2.0 (Don Syme, Adam Granicz, Antonio Cisternino)
4. Characteristics of Monads The Monadic Type “wraps” an underlying type. The monadic type may be more like an object (which may contain other data or state), or more like a computation or potential computation. The Return function wraps an underlying type in a monadic type. The Bind function takes an underlying type as well as a function which maps from the underlying type to a new monadic type, and returns a new monadic type. By performing this wrapping of underlying types inside a monadic type and providing bind and return, you can now combine computations of that inner type in ways that are difficult or impossible when just dealing with the underlying types.
7. One use of Monads: Sequential Workflows As noted, there are many uses and varieties of Monads We will concentrate on solving a typical sequential workflow style problem First showing other ways this has been done without workflows, then building up to using an F# workflow
8. Sequential Workflows: If/else The following code takes an initial input (of type T) and performs 3 sets of transformations on it, each time returning a tuple of bool and Result object (of type T). If there is a failure at any step, the entire operation is short circuited. let process1 = true, input // do something with input let process2 = false, input let process3 = true, input let Execute (input : 'T) = let ok, result1 = process1 input if ok then let ok, result2 = process2 result1 if ok then let ok, result3 = process3 result2 ok, result3 else false, result2 else false, result1
9. If/else: Problems The processX() methods and their callers all must know about the input and result types. Generics help the situation, but still these methods are hard-wired for those specific types, plus the success/failure Boolean. Also, the 'T in Execute() and processX() is always the same! It’s getting pretty messy, and we’ve only done 3 transformations. Pretty soon the code is going to be off the right side of the screen! We have to explicitly handle failure at every step of the process Lots of redundancy. We said “ok” 6 times! We don’t have any information about what went wrong. Though we could define some sort of error type (see next example…).
10. Sequential Workflows: Option and match The following code tries to improve on the last sample. It now includes a Result<'T> type which we could expand upon to return detailed error information. It also uses pattern matching, which makes the code a bit clearer. type Result<'T> = | Success of 'T | Failure of string let process1 input = Success(input) // do something interesting here let process2 input = Failure("Some error") let process3 input = Success(input) let Process (input : 'T) = let res1 = process1 input match res1 with | Failure _ -> res1 | Success v -> let res2 = process2 v match res2 with | Failure _ -> res2 | Success v -> let res3 = process3 v res3
11. Option/match: Problems Better than if/else, but… Still messy and redundant and again the code is drifting off the right side of the screen The processX() methods and their callers still must all know about the input and result types. The 'T in Execute() and processX() is still always the same We still have to explicitly handle failure at every step of the process The Result<'T>type does seem like a nice idea
12. Sequential Workflows: try/catch Try/catch could simplify/aggregate and improve things a bit – though just for this particular case. It does look nice and streamlined, which is one thing we are looking for. exception MyProcessException of string let process1 input = input let process2 input = raise <| MyProcessException("An error occurred“) let process3 input = input // processX now accept and return T // No Result any more; exceptions are used instead let Execute (input : 'T) = try let v1 = process1 input let v2 = process2 v1 let v3 = process3 v2 v3 with | :? MyProcessException as ex -> // Catch application-specific error...do we throw or return a Result?? reraise () | exn -> // A "real" exception...what to do here? reraise () let Caller<'T> v = // This will throw underlying exception on failure // Caller's caller will also have to handle it Execute v
13. try/catch: Problems Getting better, but… Now we’re using the try/catch exception mechanism for handling short-circuiting errors rather than real exception cases. Is the exception just due to a typical error in processing or is it a “real” exception? What does the caller do in this case? Note also that it becomes difficult for the caller to now be part of a larger workflow, or else a lot of hard-coded wireup The “inner workflows” called by the top-level workflow all need to have try/catch and also throw the same Exception type (e.g. MyProcessException).
14. Sequential Workflows: Extension Methods Using Extension Methods to “chain” or “pipeline” (in a C#/Java kind of way). The output of one function feeds the input of the next. Then, we wrap the whole thing in a try/catch. exception MyException of stringtype WrapperObject(v : 'T) = let value = v member x.Value with get() = vmodule WrapperObjectExtensions = type WrapperObject with member x.Process1() = let v = x.Value + " Process1" in WrapperObject(v) member x.Process2() = let v = x.Value + " Process2" in WrapperObject(v) member x.Process3() = let v = x.Value + " Process3" in WrapperObject(v) open WrapperObjectExtensionslet Execute (input : string) = let wrapper = WrapperObject(input) try let res = wrapper.Process1().Process2().Process3() res.Value with | :? MyException as ex -> // throw or return a Result? reraise () | exn -> // A "real" exception // What to do here? reraise ()
15. Sequential Workflows: Chained Objects Using Interfaces, we return instances of object, on which further Process() can be called. module ChainableObjectsWorkflowexception MyException of stringtype IChainableObject<'T> = abstract Value : unit -> 'T with get abstract Process : ('T -> 'T) -> IChainableObject<'T>type ChainableObject<'T>(v : 'T) as this = let value = v interface IChainableObject<'T> with member x.Value with get() = value override x.Process (f : ('T -> 'T)) = let v = (this :> IChainableObject<_>).Value let res = f v ChainableObject(res) :> IChainableObject<'T>let process1 (s : string) = s + " Process1 applied"let process2 (s : string) = raise <| MyException("Error")let process3 (s : string) = s + " Process3 applied"
16. Sequential Workflows: Chained Objects (continued) Execute() function let Execute (input : string) = let co = ChainableObject(input) :> IChainableObject<_> try let res = co.Process(process1).Process(process2).Process(process3) res.Value with | :? MyException as ex -> // throw or return a Result? reraise () | exn -> // A "real" exception // What to do here? reraise ()
17. Sequential Workflows: Pipelining Similar to Extension Methods but with more idiomatic F# syntax with (|>) instead of dot syntax exception MyException of string let process1 input = input let process2 input = raise <| MyException("An error occurred") let process3 input = input let Execute (input : 'T) = try input |> process1 |> process2 |> process3 with | :? MyException as ex -> // throw or return a Result? reraise () | exn -> // A "real" exception // What to do here? reraise ()
18. Chaining, Pipelining, etc.: Problems Getting better, but… Still using the try/catch exception mechanism for handling short-circuiting errors rather than real exception cases. We just get the result of the overall computation, but not each individual piece. What if the workflow wants to perform additional processing on pieces? Once again, the 'T in Execute() and processX() is always the same
19. Help from Continuations module Continuationstype Result<'T> = | Success of 'T | Failure of stringlet process1 = (fun v -> Success("Process 1: " + v))let process2 = (fun v -> Failure("Process 2: An error occurred"))let process3 = (fun v -> Success("Process 3: " + v)) // Run f on v. If is succeeds, then call cont on that result, else return Failure // Note that cont can transform the result into another typelet executeCont v (f : 'a -> Result<'a>) (cont : 'a -> Result<'b>) : Result<'b> = let maybe = f v match maybe with | Failure(err) -> Failure(err) | Success(result) -> cont result let Execute v : Result<_> = executeCont v process1 (fun result1 -> executeCont result1 process2 (fun result2 -> executeCont result2 process3 (fun result3 -> Success(result3))))
20. Continuations Now we’re getting somewhere! Conditional computation – executeCont() can short-circuit We have access to intermediate results and could use these at any future point in the workflow The continuation function can transform the type from 'a to 'b. Now the types can be transformed in each stage of the workflow. More generic workflow helper functions (processX()) can be built which can manipulate different types. Still, ugly syntax. Could we improve on this?
21. A Better Way: F# Workflows First define a “Result” type which can be Success or Failure, plus some additional info Then define the “Monadic” type which wraps a type 'T into a function, which could be conditionally executed to return a Result Note that Attempt<'T> is basically a continuation. The Workflow Builder we create next contains the logic to run the continuation (the entire rest of the workflow) after running the current step, or else not run additional Attempts if there is a failure, and simply return out of the entire workflow type Error = { Message : string }/// A result/// If success, it contains some object, plus a message (perhaps a logging message)/// If failure, it returns an Error object (which could be expanded to be much richer)type Result<'T> =| Success of 'T * string| Failure of Errortype Attempt<'T> = (unit -> Result<'T>)
22. F# Workflow Builder: Helper functions let succeed (x,msg) = (fun () -> Success(x, msg)) : Attempt<'T>let fail err = (fun () -> Failure(err)) : Attempt<'T>let failmsg msg = (fun () -> Failure({ Message = msg })) : Attempt<'T>let runAttempt (a : Attempt<'T>) = a()let bind (f : Attempt<'T>) (rest : 'T -> Attempt<'U>) : Attempt<'U> = match runAttempt f with | Failure(msg) -> fail msg | Success(res, msg) as v -> rest reslet delay f = (fun () -> runAttempt (f()))let getValue (res:Result<'T>) = match res with | Success(v,s) -> v | Failure _ -> failwith "Invalid operation"
23. F# Workflow Builder: The Workflow Builder Object Uses the helper functions we just defined to create a “builder” class required by F# Creates “processor” which is an instance of the builder. This is used to wrap all of these workflows using processor { } notation Another “static class”, Processor, contains additional helper methods (kind of like the Async class) type ProcessBuilder() = member this.Return(x) = succeed x member this.ReturnFrom(x) = x member this.Bind(p, rest) = bind p rest member this.Delay(f) = delay f member this.Let(p, rest) : Attempt<'T> = rest ptype Processor() = static member Run workflow = runAttempt workflow let processor = new ProcessBuilder()
25. F# Workflow: Final Result See code for full example type Customer = { Name : string; Birthdate : DateTime; CreditScore : int; HasCriminalRecord : bool }let customerWorkflow c = processor { let! ageTicket = processCustomer1 c let! creditTicket = processCustomer2 c let! criminalTicket = processCustomer3 c // Process lots more stuff here...note how we can access result of each step // If we didn't get to this point, then the entire workflow would have // returned Result.Failure with the error message where the workflow failed // If we got here, then all OK, assemble results and return return ((c, [| ageTicket; creditTicket; criminalTicket |]), "Customer passed all checks!") }/// If this succeeds, it returns a Result<Customer,int[]>/// else it returns a Failure with an error messagelet results = Processor.Run (customerWorkflow customer)
26. F# Workflows: Bind De-Sugared See code for full example let customer = { Name = "Jane Doe"; DateTime.Parse("1/1/1960"); CreditScore = 640; HasCriminalRecord = false }let customerWorkflow c logger = processor { let! ageResult = processCustomer1 (c, logger) let! creditResult = processCustomer2 (c, logger) let! criminalResult = processCustomer3 (c, logger) let ageTicket = getValue(ageResult) let creditTicket = getValue(creditResult) let criminalTicket = getValue(criminalResult) return ((c, [| ageTicket; creditTicket; criminalTicket |]), "Customer passed all checks!", logger) } // De-sugars to: let finalResult = processor.Bind(processCustomer1 c, (fun ageResult -> processor.Bind(processCustomer2 c, (fun creditResult -> processor.Bind(processCustomer3 c, (fun criminalResult -> processor.Let(getValue(ageResult), (fun ageTicket -> processor.Let(getValue(creditTicket), (fun creditTicket -> processor.Let(getValue(criminalResult), (fun criminalTicket -> processor.Return (c, [|ageTicket;creditTicket;criminalTicket|], logger ))))))))))
27. ParseWorkflow Example See example in code Complete example which parses and validates a fixed-width format specification and returns Line, Position and Message on any errors
29. References Expert F# 2.0 (Don Syme, et al) Real World Functional Programming (Tomas Petricek with Jon Skeet) at http://www.manning.com/petricek/ Lots of F# and Haskell references Chance Coble “Why use Computation Workflows (aka Monads) in F#?” at http://leibnizdream.wordpress.com/2008/10/21/why-use-computation-workflows-aka-monads-in-f/ F# Survival Guide: Workflows at: http://www.ctocorner.com/fsharp/book/ch16.aspx DevHawk series: http://devhawk.net/CategoryView,category,Monads.aspx Understanding Haskell Monads (ErtugrulSöylemez) at http://ertes.de/articles/monads.html Monads are like Burritos: http://blog.plover.com/prog/burritos.html (and others) Many more