Functional linear data structures in f#

Functional Linear Data Structures in F#
Jack Fox
jackfoxy.com  craftyThoughts
@foxyjackfox
Bibliography
jackfoxy.com/Lambda_Jam_fsharp_bibliography
Sample Code
github.com/jackfoxy/FunctionalLinearDataStructures

I don’t always use purely functional,
but when I do…
--The World’s most interesting Coder

FSharpx.DataStructures
FSharpx.Collections.Experimental
FSharpx.Collections
Graphics: Cambridge University Press. Wikimedia Commons, Wikimedia Foundation

(disregarding range operations)
• Order
by construction / sorted / random
• Evaluation
eager / lazy
• Peek
first / last / indexed
• Construction
first / last / insert
• Remove
first / last / indexed
 choose 1
 choose 1
 choose 1 – 2, or #3
 choose 0 – 2, or #3
 choose 0 – 2, or #3
(insert only for sorted & random)

Think we missed something?
Update is deconstruction followed by construction
List.Length is O(n)
peek at one element at a time
equivalent of complete deconstruction

 List, Tuple
 seq{ } (the phantom data structure)
 Array (but it’s mutable)
∞
Graphics: unattributed, all over the internet

List Update
let rec loop i updateElem myList =
match (i, myList) with
| i', [] -> invalidArg
| 0, x::xs -> updateElem::xs
| i', x::xs -> x::(loop (i' - 1) y xs)
[ ]1234 :: :: ::
found it!

Performance
Graphics : www.clker.com, jackfoxy
[] JIT

[<Struct>]
type FlatList<'T> =
val internal array : 'T[]
internal new (arr: 'T[]) =
{ array = (match arr with null -> null
| arr -> if arr.Length = 0 then null else arr) }
member x.Item with get(n:int) = x.array.[n]
member x.Length = match x.array with null -> 0 | arr -> arr.Length
member x.IsEmpty = match x.array with null -> true | _ -> false
static member Empty : FlatList<'T> = FlatList(null)
interface IEnumerable<'T> with
member x.GetEnumerator() : IEnumerator<'T> =
match x.array with
| null -> Seq.empty.GetEnumerator()
| arr -> (arr :> IEnumerable<'T>).GetEnumerator()
interface IEnumerable with
member x.GetEnumerator() : IEnumerator =
match x.array with
| null -> (Seq.empty :> IEnumerable).GetEnumerator()
| arr -> (arr :> IEnumerable).GetEnumerator()

Performance Tip
Nothing beats Tuple
…and Record is Tuple with named Elements
…and Tuple/Record is heterogenous

The Downside
Tuple does not implement Seq

Seq lets you transform structures
let thisIsTrue =
seq {1..10}
|> Array.ofSeq
|> Deque.ofSeq
|> DList.ofSeq
|> FlatList.ofSeq
|> Heap.ofSeq false
|> LazyList.ofSeq
|> Queue.ofSeq
|> RandomAccessList.ofSeq
|> Vector.ofSeq
|> List.ofSeq = [1..10]

…and apply any of 68 Seq Module functions
seq {1.0..10.0} |> Heap.ofSeq false
|> Seq.average
seq {1..10} |> Deque.ofSeq
|> Seq.fold (fun state t -> (2 * t)::state) []
seq {1..10} |> RandomAccessList.ofSeq
|> Seq.mapi (fun i t -> i * t)
seq {1..10} |> Vector.ofSeq
|> Seq.reduce (fun acc t -> acc * t )

Unfold Infinite Sequences
unfold
starts
here

let NextState (today, (random:Random), i) =
let nextDay = nextDayWeather today (random.NextDouble())
printfn "day %i is forecast %A" i nextDay
Some (nextDay, (nextDay, random, (i + 1L)))
let forecastDays =
Seq.unfold NextState (Sunny, (new Random()), 0L)
printfn "%A" (Seq.take 5 forecastDays |> Seq.toList)
> day 0 is forecast Sunny
day 1 is forecast Sunny
day 2 is forecast Cloudy
day 3 is forecast Rainy
[Sunny; Sunny; Cloudy; Rainy; Cloudy]

printfn "%A" (Seq.skip 5 forecastDays |> Seq.take 5 |> Seq.toList)
…
[Cloudy; Rainy; Sunny; Cloudy; Sunny]
printfn "don't try this at home! %i"
(Seq.length forecastDays)
printfn "don't try this at home either! %A"
(forecastDays |> List.ofSeq)

So far:
Functional Data Structures
Linear Structures as an abstraction
Seq as the unifying abstraction
Next:
More choices

[Sunny; Cloudy; Sunny; Sunny; Cloudy]
[Sunny; Sunny; Sunny; Sunny; Sunny; Sunny; Cloudy]
Inconsistent!

LazyList: seq-like & List-like
let lazyWeatherList =
LazyList.unfold NextState (Sunny, (new Random()), 0L)
printfn "%A" (LazyList.take 3 lazyWeatherList)
[Sunny; Sunny; Cloudy]
printfn "%A" (LazyList.take 4 lazyWeatherList)
> day 3 is forecast Cloudy
[Sunny; Sunny; Cloudy ; Cloudy]

Skip always evaluates
LazyList.ofSeq (seq {for i = 1 to 10 do
yield (nextItem i)})
|> LazyList.skip 2
|> LazyList.take 2
|> List.ofSeq
> item 1
item 2
item 3
item 4

O(1) Append
let observedWeatherList =
LazyList.ofList [Sunny; Sunny; Cloudy; Cloudy; Rainy;]
let combinedWeatherList =
LazyList.append observedWeatherList lazyWeatherList
printfn "%A" (LazyList.skip 4 combinedWeatherList
|> LazyList.take 3)
> day 0 is forecast Rainy
seq [Rainy; Rainy; Cloudy]
Observed Predicted

List - like
[ ]5432
Construct
Deconstruct
Tail
Hea
d
1
empt
y
:
:
…and the only data element
accessible!

Vector
54321
Construct
Deconstruct
Initia
l
Las
t
[ ]
empt
y
;
;

Windowing a sequence
let windowFun windowLength =
fun (v : Vector<Vector<Weather>>) t ->
if v.Last.Length = windowLength
then
v |> Vector.conj (Vector.empty.Conj(t))
else
Vector.initial v
|> Vector.conj (Vector.last v |> Vector.conj t)

Windowing a sequence
let windowedForecast =
Seq.unfold NextState (Sunny, (new Random()), 0L)
|> Seq.truncate 365
|> Seq.fold (windowFun 7)
(Vector.empty.Conj Vector.empty<Weather>)

Fold on Vector Windows
let initialFun =
fun (v : Vector<Vector<Weather>>) (t : Vector<Weather>)
-> Vector.conj t.Initial v
let sabbathRespectingForecast =
windowedForecast
|> Vector.fold initialFun Vector.empty<Vector<Weather>>

RandomAccessList
54321
Construct
Deconstruct
Tai
l
Hea
d
[ ]
empt
y
:
:

Multiway Tree
type 'a MultiwayTree = {Root: 'a; Children: 'a MultiwayForest}
with
…
and 'a MultiwayForest = 'a MultiwayTree Vector
let inline create root children = {Root = root; Children = children}
let inline singleton x = create x Vector.empty

Forest from the Windows
let inline forestFromSeq (s : #seq<#seq<_>>) (f : #seq<'a> -> 'a) =
let rec loop acc l =
match l with
| [] -> acc
| head::tail ->
let forest = Seq.fold
(fun s t -> Vector.conj(singleton t) s)
Vector.empty<_>
head
loop (Vector.conj (create (f head) forest) acc) tail
loop Vector.empty<MultiwayTree<_>> (List.ofSeq s)

DList (append list)
54:: 321
Head Tail
;;
Construct
Deconstruct Construct

Queue (FIFO)
54:: 321
Head Tail
;;
Deconstruct Construct

Breadth 1st Traversal
let inline breadth1stForest forest =
let rec loop acc dl =
match dl with
| DList.Nil -> acc
| DList.Cons(head, tail) ->
loop (Queue.conj head.Root acc)
(DList.append tail (DList.ofSeq head.Children))
loop Queue.empty (DList.ofSeq forest)

Deque (double-ended queue)
54:: 321
Head Tail
;;
Init Last
Construct
Deconstruct
Construct
Deconstruct

match forecast with
| Rainy::tail -> printfn "tomorrow will be rainy"
| _::tail ->
match (LazyList.ofSeq tail) with
| LazyList.Nil -> printfn "only 1 day in the forecast"
| LazyList.Cons(Rainy, tail) -> printfn "the day after tomorrow will be rainy"
| LazyList.Cons(_, tail) ->
match (Deque.ofSeq tail) with
| Deque.Nil -> printfn "only 2 days in the forecast"
| Deque.Cons(Rainy, Deque.Conj(initial, Rainy)) -> printfn "3rd & last day rainy"
| x ->
match (DList.ofSeq x) with
| DList.NilDL -> printfn "only 3 days in the forecast"
| DList.Cons(_, DList.Cons(Rainy, _)) -> printfn "4th day to be rainy"
| x ->
match (Queue.ofSeq x) with
| Queue.Nil -> printfn "only 4 days in the forecast"
| Queue.Cons(_, tail) ->
match (RandomAccessList.ofSeq tail) with
| RandomAccessList.Nil -> printfn "only 5 days in the forecast"
| RandomAccessList.Cons(_, tail) ->
match (Vector.ofSeq tail) with
| Vector.Nil -> printfn "only 6 days in the forecast"
| Vector.Conj(initial, lastDay) -> printfn "last day is %A" lastDay

What are
We Missing?
We’ve seen
The right structure for the right job

Heap (ordered)
::1
Head Tail
Deconstruct
Construct
Graphics: http://www.turbosquid.com/3d-models/heap-gravel-max/668104

The Future?
Data Frames
Random Stack
Purely Functional Circular Buffer
Keep on experimenting

Functional linear data structures in f#

More Related Content

What's hot

Similar to Functional linear data structures in f#

More from Jack Fox

Recently uploaded

Functional linear data structures in f#

Editor's Notes