• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Creating Domain Specific Languages in F#
 

Creating Domain Specific Languages in F#

on

  • 2,667 views

When designing software, we often need to solve numerous instances of the same problem. When designing user-interfaces, we need to describe the layout and interaction. When financial systems, we need ...

When designing software, we often need to solve numerous instances of the same problem. When designing user-interfaces, we need to describe the layout and interaction. When financial systems, we need to describe a wide range of financial contracts or, for example, recognize different patterns in price change.

Domain Specific Languages (DSLs) give us a way to solve such repeating problems. By designing a composable functional library, we can build an expressive language for describing our problems. Using the flexible F# syntax, we can get code that even non-programmers can understand.

In this practically oriented talk, we'll develop a number of sample DSLs, ending with realistic examples. We'll cover both basic principles of DSL design as well as advanced tricks, such as using the F# 3.0 query syntax.

Statistics

Views

Total Views
2,667
Views on SlideShare
2,660
Embed Views
7

Actions

Likes
5
Downloads
33
Comments
0

2 Embeds 7

http://www.linkedin.com 4
https://www.linkedin.com 3

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment
  • Prefer internal DSLs

Creating Domain Specific Languages in F# Creating Domain Specific Languages in F# Presentation Transcript

  • Creating Domain Specific Languages in F# PhD student @ University of Cambridgetomas@tomasp.net Tomas Petricek @tomaspetricek Conspirator behind http://fsharp.org
  • Real World Functional Programming tutorials F# and C# monads functional concepts practical examples industry experts F# Deep Dives . domain modeling financial & insurance web & data actor model concurrency social gamingF# Trainings & Consultingtesting London async & concurrent New York DSLsdata processing http://functional-programming.net
  • software stacks trainings teaching F# user groups snippetsmac and linux cross-platform books and tutorials F# Software Foundation F# community open-source MonoDevelop http://www.fsharp.org contributions research support consultancy mailing list
  • Domain-specific languagesWe have a class of problems Create a language for the class Use language to solve themDSLs and functional languages Internal DSLs are just library External DSLs are easier to build
  • Domain-specific languagesLanguage for solving specific problems Fun.cylinder |> Fun.translate (0, 0, 1) |> Fun.color Color.Gold $ Fun.cone |> Fun.color Color.DarkRedContrast with general purpose languages
  • Demo: Building a castleDomain Specific Language Defines a few simple primitives Extensible by compositionSingle-purpose or general-purpose? Most code is single-purpose Can use general-purpose if neededSee also FAKE: the F# Make
  • Building a DSL for: Option Pricing
  • Demo: Modeling Euro optionsWhat is the language? Primitive values Composition operationsHow do we use the model? Drawing a pay-off diagram Calculating option price Checking for execution
  • Composed options
  • Building the modelPrimitives of the language type OptionKind = Call | Put type Option = | European of OptionKind * floatComposition combinators | Combine of Option * Option | Times of float * Option
  • Demo: Building & using the DSLMake it more convenient Custom operators Derived primitivesUse it for its purpose Drawing pay-off diagrams Evaluating option price
  • Domain-specific languagesAdvantages DisadvantagesReadability Additional abstraction Greater for External DSL Smaller for Internal DSLMaintainability Time to implement Hides the implementation Easier for Internal DSL Internals can be changed Time to learnDomain Focus Avoid crazy operators Non-experts can read it Make it familiar
  • Internal DSL: Building BlocksVanilla .NET F# SpecificMethod chaining PipeliningEnumerations Discriminated UnionsClasses RecordsOperator Overloading Custom OperatorsAttributes QuotationsIterators & LINQ Computation ExpressionsExtension methods Functions
  • Building a DSL for:Detecting Price Patterns
  • Declining pattern
  • Rounding top pattern
  • Multiple bottom pattern
  • Doman-specific language approachPrimitive classifiers Declining price Rising priceCombinators for classifiers Average using regression Sequence multiple patterns Check patterns at the same time
  • Demo: Detecting price patternsBuilding complex from simple Check multiple conditions let bothAnd a b = both a b |> map (fun (a, b) -> a && b) Calculate minimum value let minimum = reduce min |> map (fun v -> Math.Round(v, 2)) All values are in a range let inRange min max = bothAnd (atLeast min) (atMost max)
  • How does it work?What is a classifier? type Classifier<T> = ClassifyFunc of ((DateTime * float)[] -> T)A function value! Given data, calculate the result Generic – can produce any value Abstract – representation is hidden
  • Demo: Detecting more patternsDouble bottom pattern Change over regression Down–Up two timesDeclining fast pattern Declining over regression (Max – Min) > 3 USD
  • Advanced Techniques for Embedded DSLs
  • Advanced Embedded DSLsComputation expressions Reinterpret expression composition Add constructs with F# 3.0 queriesMeta-programming with quotations Reinterpret F# expressionsActive patterns More expressive pattern language Implementing external DSLs
  • Repeating patterns in DSLsRepeating functions in DSLs Map: transform the produced value (T -> R) -> Clsif<T> -> Clsif<R> Bind & return: composition of computations (T -> Clsif<R>) -> Clsif<T> -> Clsif<R> T -> Clsif<T>Simplify using them? With language syntax?
  • F# computation expressionsSyntax for computations For types with certain operations Aka monads in HaskellDeclining fast pattern classify { let! max = P.maximum let! min = P.minimum let! upwards = P.regression P.rising return upwards & (abs (min - max) > 3.0) }
  • F# query expressionsCustomize the meaning of a query event { for e in frm.MouseDown do pairwise into (e1, e2) select (e1.X - e2.X, e1.Y - e2.Y) into r iter (printfn "%A" r) }Query for event processing Custom operators e.g. iter, select, pairwise Transformations, joins, merging and more Full power to be explored!
  • F# active patternsExtending the pattern language match input with | Bracketed * * (body, rest) -> (...) | Bracketed [ ] (body, Bracketed ( ) (link, rest)) -> (...) | _ -> (...)Parsing Markdown format Detecting character patterns Detecting multi-line patterns See more at http://manning.com/petricek2
  • Summary
  • How To: Building your own DSL ❶ Understand Primitives and Combinators ❷ Model the language using Discriminated Unions ❸ Add convenient Syntax
  • For more information…Learn and explore F# Read tutorials at http://tryfsharp.orgJoin & help with F# Foundation Visit http://fsharp.org and for on GitHub!New York F# Trainings & Tutorials in May Check out: http://functional-programming.net Contact me directly: tomas@tomasp.net