programming languages: prolog, clojure, f# jared wheeler

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