programming languages: prolog, clojure, f# jared wheeler
TRANSCRIPT
PROGRAMMING LANGUAGES:PROLOG, CLOJURE, F#
Jared Wheeler
Prolog
1972 Development Declarative Language No Algorithms
Define the Problem It finds the answer
Parts
Knowledge Base Facts
Basic Assertions Rules
Inferences about Facts
Queries
Naming
constant Variable or _variable List – [1, 2, 3] Tuple – (1, 2, 3)
Fixed Length
Unification
No Assignments Prolog tries to make variables and
constants equal If succeeds, an inference can be made
Results
Yes No
Answers unasked question of if execution completed
Recursion
Call Rule from within Rule Tail-Recursion Optimization
Put Recursive call at End Prolog keeps memory use steady
Uses
Solving Systems within Constraints Puzzles Natural Language Processing AI
Weaknesses
Utility Scaling to Large Data Sets
Depth First Search for Answers Learning Curve
Prolog Demo
Knowledge Base File Execution
Clojure
Lisp for JVM Scheme, lisp-1, not Common Lisp, lisp-2 Difference in namespacing functions and
data Data As Code
Variables
(def variableName item) Prefix notation
(let value variableBound) Temporary binding of value to a variable
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
Functions
(defn name [parameters] body) Parameters within a vector
(fn [parameters] body) Anonymous function
Recursion
No Tail-Recursion Optimization Working around JVM too much (loop [parameter1 boundVariable, …]
(recur (parameter1In)))
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
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
Concurrency
Software Transactional Memory Inspired by database transactions (def reference (ref “some data”))
@reference gives “some data” Cannot change without a dosync function
Interfaces
defprotocol Define a contract
defrecord Implements the protocol
Records are immutable
Macros
Two stages of Clojure Execution Macro Expansion Execution
defmacro to Create
Strengths
Powerful and Flexible Use of JVM Lisp minus parenthesis and reader
macros Concurrency Lazy Evaluations
Weaknesses
Complex Prefix Notation Readability Complex Recursion Optimization
Compared to other Functional Languages
Clojure Demo
General Form
F#
Built by Microsoft Research Runs on the .NET Framework
Variables
Assignments by Let statements Immutable unless ‘modifiable’ attribute at
declaration Statically Typed
Strong Type Inferencing
Functions
Let functionName Parameters = body Whitespace-sensitive Parameters have type inferencing
Sometimes require (variableName:type) Functions can be Passed as Parameters
Anonymous Functions
Lambda Expressions (fun params -> body)
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
Array
[| 1; 2; 3|]
Record
Grouped Data with Member Names Immutable
Defines data types Keyword type to define
Mutate using with Members can be optional
Discriminating Joins
EnumerationType object = | Option1| Option2
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
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
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
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
F# Demo
General Form Record Creation Record Mutation