1. PROGRAMMING LANGUAGES: PROLOG, CLOJURE, F# Jared Wheeler

2. Prolog  1972 Development  Declarative Language  No Algorithms  Define the Problem  It finds the answer

3. Parts  Knowledge Base  Facts Basic Assertions  Rules Inferences about Facts  Queries

4. Naming  constant  Variable or _variable  List – [1, 2, 3]  Tuple – (1, 2, 3)  Fixed Length

5. Unification  No Assignments  Prolog tries to make variables and constants equal  If succeeds, an inference can be made

6. Results  Yes  No  Answers unasked question of if execution completed

7. Recursion  Call Rule from within Rule  Tail-Recursion Optimization  Put Recursive call at End  Prolog keeps memory use steady

8. Uses  Solving Systems within Constraints  Puzzles  Natural Language Processing  AI

9. Weaknesses  Utility  Scaling to Large Data Sets  Depth First Search for Answers  Learning Curve

10. Prolog Demo  Knowledge Base File  Execution

11. Clojure  Lisp for JVM  Scheme, lisp-1, not Common Lisp, lisp-2  Difference in namespacing functions and data  Data As Code

12. Variables  (def variableName item)  Prefix notation  (let value variableBound)  Temporary binding of value to a variable

13. Data Structures  List – Ordered Collection ()  Hold Code  First element is always executed as a function  Vector – Ordered Collection []  Hold Data  Map – Key-value Pairs {}  Clojure allows comma delimitations  Keys can be used as functions to retrieve the value  Set – Unordered Collection #{}  Can be used as a function to find if an item is included

14. Functions  (defn name [parameters] body)  Parameters within a vector  (fn [parameters] body)  Anonymous function

15. Recursion  No Tail-Recursion Optimization  Working around JVM too much  (loop [parameter1 boundVariable, …] (recur (parameter1In)))

16. Sequences  Common Parent to Most Data Structures  Comes with many default functions  every?, some?, filter, map, reduce, sort  (for [x seq] function) Binds each member of the seq to x one at a time

17. Lazy Evaluation  (repeat 1)  Repeats 1 until the process is killed  (take 5 (repeat 1))  Repeats 1 five times  Lazy Evaluation means infinite sets can be computed Evaluations only occur once needed

18. Concurrency  Software Transactional Memory  Inspired by database transactions  (def reference (ref “some data”)) @reference gives “some data” Cannot change without a dosync function

19. Interfaces  defprotocol  Define a contract  defrecord  Implements the protocol  Records are immutable

20. Macros  Two stages of Clojure Execution  Macro Expansion  Execution  defmacro to Create

21. Strengths  Powerful and Flexible  Use of JVM  Lisp minus parenthesis and reader macros  Concurrency  Lazy Evaluations

22. Weaknesses  Complex  Prefix Notation  Readability  Complex Recursion Optimization  Compared to other Functional Languages

23. Clojure Demo  General Form

24. F#  Built by Microsoft Research  Runs on the.NET Framework

25. Variables  Assignments by Let statements  Immutable unless ‘modifiable’ attribute at declaration  Statically Typed  Strong Type Inferencing

26. Functions  Let functionName Parameters = body  Whitespace-sensitive  Parameters have type inferencing  Sometimes require (variableName:type)  Functions can be Passed as Parameters

27. Anonymous Functions  Lambda Expressions  (fun params -> body)

28. Lists  [ 1; 2; 3] = [1..4]  Ranges allowed  List.map (function) listName  Applies a function to all members  List.filter (function) listName  Returns members that the function returns true for

29. Array  [| 1; 2; 3|]

30. Record  Grouped Data with Member Names  Immutable  Defines data types  Keyword type to define  Mutate using with  Members can be optional

31. Discriminating Joins  Enumeration Type object = | Option1 | Option2

32. Forward Pipe Operator List.sum (List.map (fun x -> x * 2) (List.filter (fun x -> x % 2 = 0) [0..100]))  Into this: [0..100] |> List.filter (fun x -> x % 2 = 0) |> List.map (fun x -> x * 2) |> List.sum

33. Currying  Functions Have One Parameter  Return a function asking for the next  Repeats until all parameters are accounted for  Parameter order matters  Allows for New Operators Easier  Also allows for different form of overloading

34. Operators  Overload Only a Select set of Operators  Otherwise overwrites  Unless done within a type  Define new Operator For One Parameter  Works due to currying

35. Sublanguages  Active Patterns  Pattern Matching  Customizable  Allows labels within a pattern to call a function  Quotations  Stores code fragments  Type Checks, but no execution F# 3.0 has Type Provider that can execute  Together, they allow Sublanguages or Cross-Compilation

36. F# Demo  General Form  Record Creation  Record Mutation